//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS CodeCommit service.
///
/// CodeCommit This is the CodeCommit API Reference. This reference provides descriptions of the operations and data types for  CodeCommit API along with usage examples. You can use the CodeCommit API to work with the following objects: Repositories, by calling the following:    BatchGetRepositories, which returns information about one or more repositories associated with your Amazon Web Services account.    CreateRepository, which creates an CodeCommit repository.    DeleteRepository, which deletes an CodeCommit repository.    GetRepository, which returns information about a specified repository.    ListRepositories, which lists all CodeCommit repositories associated with your Amazon Web Services account.    UpdateRepositoryDescription, which sets or updates the description of the repository.    UpdateRepositoryEncryptionKey, which updates the Key Management Service encryption key used to encrypt and decrypt a repository.    UpdateRepositoryName, which changes the name of the repository. If you change the name of a repository, no other users of that repository can access it until you send them the new HTTPS or SSH URL to use.   Branches, by calling the following:    CreateBranch, which creates a branch in a specified repository.    DeleteBranch, which deletes the specified branch in a repository unless it is the default branch.    GetBranch, which returns information about a specified branch.    ListBranches, which lists all branches for a specified repository.    UpdateDefaultBranch, which changes the default branch for a repository.   Files, by calling the following:    DeleteFile, which deletes the content of a specified file from a specified branch.    GetBlob, which returns the base-64 encoded content of an individual Git blob object in a repository.    GetFile, which returns the base-64 encoded content of a specified file.    GetFolder, which returns the contents of a specified folder or directory.    ListFileCommitHistory, which retrieves a list of commits and changes to a specified file.     PutFile, which adds or modifies a single file in a specified repository and branch.   Commits, by calling the following:    BatchGetCommits, which returns information about one or more commits in a repository.    CreateCommit, which creates a commit for changes to a repository.    GetCommit, which returns information about  a commit, including commit  messages and author and committer information.    GetDifferences, which returns information about the differences in a valid commit specifier (such as a branch, tag, HEAD, commit ID, or other fully qualified reference).   Merges, by calling the following:    BatchDescribeMergeConflicts, which returns information about conflicts in a merge between commits in a repository.    CreateUnreferencedMergeCommit, which creates an unreferenced commit between two branches or commits for the purpose of comparing them and identifying any potential conflicts.    DescribeMergeConflicts, which returns information about merge conflicts between the base, source, and destination versions of a file in a potential merge.    GetMergeCommit, which returns information about the merge between a source and destination commit.     GetMergeConflicts, which returns information about merge conflicts between the source and destination branch in a pull request.    GetMergeOptions, which returns information about the available merge options between two branches or commit specifiers.    MergeBranchesByFastForward, which merges two branches using the fast-forward merge option.    MergeBranchesBySquash, which merges two branches using the squash merge option.    MergeBranchesByThreeWay, which merges two branches using the three-way merge option.   Pull requests, by calling the following:    CreatePullRequest, which creates a pull request in a specified repository.    CreatePullRequestApprovalRule, which creates an approval rule for a specified pull request.    DeletePullRequestApprovalRule, which deletes an approval rule for a specified pull request.    DescribePullRequestEvents, which returns information about one or more pull request events.    EvaluatePullRequestApprovalRules, which evaluates whether a pull request has met all the conditions specified in its associated approval rules.    GetCommentsForPullRequest, which returns information about comments on a specified pull request.    GetPullRequest, which returns information about a specified pull request.    GetPullRequestApprovalStates, which returns information about the approval states for a specified pull request.    GetPullRequestOverrideState, which returns information about whether approval rules have been set aside (overriden) for a  pull request, and if so, the Amazon Resource Name (ARN) of the user or identity that overrode the rules and their requirements for the pull request.    ListPullRequests, which lists all pull requests for a repository.    MergePullRequestByFastForward, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the fast-forward merge option.    MergePullRequestBySquash, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the squash merge option.    MergePullRequestByThreeWay, which merges the source destination branch of a pull request into the specified destination branch for that pull request using the three-way merge option.    OverridePullRequestApprovalRules, which sets aside all approval rule requirements for a pull request.    PostCommentForPullRequest, which posts a comment to a pull request at the specified line, file, or request.    UpdatePullRequestApprovalRuleContent, which updates the structure of an approval rule for a pull request.    UpdatePullRequestApprovalState, which updates the state of an approval on a pull request.    UpdatePullRequestDescription, which updates the description of a pull request.    UpdatePullRequestStatus, which updates the status of a pull request.    UpdatePullRequestTitle, which updates the title of a pull request.   Approval rule templates, by calling the following:    AssociateApprovalRuleTemplateWithRepository, which associates a template with a specified repository. After the template is associated with a repository, CodeCommit creates approval rules that match the template conditions on every pull request created in the specified repository.    BatchAssociateApprovalRuleTemplateWithRepositories, which associates a template with one or more specified repositories. After the template is associated with a repository, CodeCommit creates approval rules that match the template conditions on every pull request created in the specified repositories.    BatchDisassociateApprovalRuleTemplateFromRepositories, which removes the association between a template and specified repositories so that approval rules based on the template are not automatically created when pull requests are created in those repositories.    CreateApprovalRuleTemplate, which creates a template for approval rules that can then be associated with one or more repositories in your Amazon Web Services account.    DeleteApprovalRuleTemplate, which deletes the specified template. It does not remove approval rules on pull requests already created with the template.    DisassociateApprovalRuleTemplateFromRepository, which removes the association between a template and a repository so that approval rules based on the template are not automatically created when pull requests are created in the specified repository.    GetApprovalRuleTemplate, which returns information about an approval rule template.    ListApprovalRuleTemplates, which lists all approval rule templates in the Amazon Web Services Region in your Amazon Web Services account.    ListAssociatedApprovalRuleTemplatesForRepository, which lists all approval rule templates that are associated with a specified repository.    ListRepositoriesForApprovalRuleTemplate, which lists all repositories associated with the specified approval rule template.    UpdateApprovalRuleTemplateDescription, which updates the description of an approval rule template.    UpdateApprovalRuleTemplateName, which updates the name of an approval rule template.    UpdateApprovalRuleTemplateContent, which updates the content of an approval rule template.   Comments in a repository, by calling the following:    DeleteCommentContent, which deletes the content of a comment on a commit in a repository.    GetComment, which returns information about a comment on a commit.    GetCommentReactions, which returns information about emoji reactions to comments.    GetCommentsForComparedCommit, which returns information about comments on the comparison between two commit specifiers  in a repository.    PostCommentForComparedCommit, which creates a comment on the comparison between two commit specifiers in a repository.    PostCommentReply, which creates a reply to a comment.    PutCommentReaction, which creates or updates an emoji reaction to a comment.    UpdateComment, which updates the content of a comment on a commit in a repository.   Tags used to tag resources in CodeCommit (not Git tags), by calling the following:    ListTagsForResource, which gets information about Amazon Web Servicestags for a specified Amazon Resource Name (ARN) in CodeCommit.    TagResource, which adds or updates tags for a resource in CodeCommit.    UntagResource, which removes tags for a resource in CodeCommit.   Triggers, by calling the following:    GetRepositoryTriggers, which returns information about triggers configured  for a repository.    PutRepositoryTriggers, which replaces all triggers for a repository and can  be used to create or delete triggers.    TestRepositoryTriggers, which tests the functionality of a repository trigger  by sending data to the trigger target.   For information about how to use CodeCommit, see the CodeCommit User Guide.
public struct CodeCommit: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the CodeCommit client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "CodeCommit_20150413",
            serviceName: "CodeCommit",
            serviceIdentifier: "codecommit",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2015-04-13",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: CodeCommitErrorType.self,
            xmlNamespace: "http://codecommit.amazonaws.com/doc/2015-04-13",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "codecommit-fips.ca-central-1.amazonaws.com",
            "us-east-1": "codecommit-fips.us-east-1.amazonaws.com",
            "us-east-2": "codecommit-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "codecommit-fips.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "codecommit-fips.us-gov-west-1.amazonaws.com",
            "us-west-1": "codecommit-fips.us-west-1.amazonaws.com",
            "us-west-2": "codecommit-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Creates an association between an approval rule template and a specified repository. Then, the next time a pull request is created in the repository where the destination reference (if specified) matches the destination reference (branch) for the pull request, an approval rule that matches the template conditions is automatically created for that pull request. If no destination references are specified in the template, an approval rule that matches the template contents is created for all pull requests in that repository.
    @Sendable
    @inlinable
    public func associateApprovalRuleTemplateWithRepository(_ input: AssociateApprovalRuleTemplateWithRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateApprovalRuleTemplateWithRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an association between an approval rule template and a specified repository. Then, the next time a pull request is created in the repository where the destination reference (if specified) matches the destination reference (branch) for the pull request, an approval rule that matches the template conditions is automatically created for that pull request. If no destination references are specified in the template, an approval rule that matches the template contents is created for all pull requests in that repository.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name for the approval rule template.
    ///   - repositoryName: The name of the repository that you want to associate with the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateApprovalRuleTemplateWithRepository(
        approvalRuleTemplateName: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateApprovalRuleTemplateWithRepositoryInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            repositoryName: repositoryName
        )
        return try await self.associateApprovalRuleTemplateWithRepository(input, logger: logger)
    }

    /// Creates an association between an approval rule template and one or more specified repositories.
    @Sendable
    @inlinable
    public func batchAssociateApprovalRuleTemplateWithRepositories(_ input: BatchAssociateApprovalRuleTemplateWithRepositoriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchAssociateApprovalRuleTemplateWithRepositoriesOutput {
        try await self.client.execute(
            operation: "BatchAssociateApprovalRuleTemplateWithRepositories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an association between an approval rule template and one or more specified repositories.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the template you want to associate with one or more repositories.
    ///   - repositoryNames: The names of the repositories you want to associate with the template.  The length constraint limit is for each string in the array. The array itself can be empty.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchAssociateApprovalRuleTemplateWithRepositories(
        approvalRuleTemplateName: String,
        repositoryNames: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchAssociateApprovalRuleTemplateWithRepositoriesOutput {
        let input = BatchAssociateApprovalRuleTemplateWithRepositoriesInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            repositoryNames: repositoryNames
        )
        return try await self.batchAssociateApprovalRuleTemplateWithRepositories(input, logger: logger)
    }

    /// Returns information about one or more merge conflicts in the attempted merge of two commit specifiers using the squash or three-way merge strategy.
    @Sendable
    @inlinable
    public func batchDescribeMergeConflicts(_ input: BatchDescribeMergeConflictsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDescribeMergeConflictsOutput {
        try await self.client.execute(
            operation: "BatchDescribeMergeConflicts", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about one or more merge conflicts in the attempted merge of two commit specifiers using the squash or three-way merge strategy.
    ///
    /// Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - filePaths: The path of the target files used to describe the conflicts. If not specified, the default is all conflict files.
    ///   - maxConflictFiles: The maximum number of files to include in the output.
    ///   - maxMergeHunks: The maximum number of merge hunks to include in the output.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository that contains the merge conflicts you want to review.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDescribeMergeConflicts(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        filePaths: [String]? = nil,
        maxConflictFiles: Int? = nil,
        maxMergeHunks: Int? = nil,
        mergeOption: MergeOptionTypeEnum,
        nextToken: String? = nil,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDescribeMergeConflictsOutput {
        let input = BatchDescribeMergeConflictsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            filePaths: filePaths, 
            maxConflictFiles: maxConflictFiles, 
            maxMergeHunks: maxMergeHunks, 
            mergeOption: mergeOption, 
            nextToken: nextToken, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.batchDescribeMergeConflicts(input, logger: logger)
    }

    /// Removes the association between an approval rule template and one or more specified repositories.
    @Sendable
    @inlinable
    public func batchDisassociateApprovalRuleTemplateFromRepositories(_ input: BatchDisassociateApprovalRuleTemplateFromRepositoriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput {
        try await self.client.execute(
            operation: "BatchDisassociateApprovalRuleTemplateFromRepositories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the association between an approval rule template and one or more specified repositories.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the template that you want to disassociate from one or more repositories.
    ///   - repositoryNames: The repository names that you want to disassociate from the approval rule template.  The length constraint limit is for each string in the array. The array itself can be empty.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDisassociateApprovalRuleTemplateFromRepositories(
        approvalRuleTemplateName: String,
        repositoryNames: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput {
        let input = BatchDisassociateApprovalRuleTemplateFromRepositoriesInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            repositoryNames: repositoryNames
        )
        return try await self.batchDisassociateApprovalRuleTemplateFromRepositories(input, logger: logger)
    }

    /// Returns information about the contents of one or more commits in a repository.
    @Sendable
    @inlinable
    public func batchGetCommits(_ input: BatchGetCommitsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetCommitsOutput {
        try await self.client.execute(
            operation: "BatchGetCommits", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the contents of one or more commits in a repository.
    ///
    /// Parameters:
    ///   - commitIds: The full commit IDs of the commits to get information about.  You must supply the full SHA IDs of each commit. You cannot use shortened SHA IDs.
    ///   - repositoryName: The name of the repository that contains the commits.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetCommits(
        commitIds: [String],
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetCommitsOutput {
        let input = BatchGetCommitsInput(
            commitIds: commitIds, 
            repositoryName: repositoryName
        )
        return try await self.batchGetCommits(input, logger: logger)
    }

    /// Returns information about one or more repositories.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    @Sendable
    @inlinable
    public func batchGetRepositories(_ input: BatchGetRepositoriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetRepositoriesOutput {
        try await self.client.execute(
            operation: "BatchGetRepositories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about one or more repositories.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    ///
    /// Parameters:
    ///   - repositoryNames: The names of the repositories to get information about.  The length constraint limit is for each string in the array. The array itself can be empty.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetRepositories(
        repositoryNames: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetRepositoriesOutput {
        let input = BatchGetRepositoriesInput(
            repositoryNames: repositoryNames
        )
        return try await self.batchGetRepositories(input, logger: logger)
    }

    /// Creates a template for approval rules that can then be associated with one or more repositories in your Amazon Web Services account. When you associate a template with a repository,  CodeCommit creates an approval rule that matches the conditions of the template for all pull requests that meet the conditions of the template. For more information, see AssociateApprovalRuleTemplateWithRepository.
    @Sendable
    @inlinable
    public func createApprovalRuleTemplate(_ input: CreateApprovalRuleTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateApprovalRuleTemplateOutput {
        try await self.client.execute(
            operation: "CreateApprovalRuleTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a template for approval rules that can then be associated with one or more repositories in your Amazon Web Services account. When you associate a template with a repository,  CodeCommit creates an approval rule that matches the conditions of the template for all pull requests that meet the conditions of the template. For more information, see AssociateApprovalRuleTemplateWithRepository.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateContent: The content of the approval rule that is created on pull requests in associated repositories. If you specify one or more destination references (branches), approval rules are created in an associated repository only if their destination references (branches) match those specified in the template.  When you create the content of the approval rule template, you can specify approvers in an approval pool in one of two ways:    CodeCommitApprovers: This option only requires an Amazon Web Services account and a resource. It can be used for both IAM users and federated access users whose name matches the provided resource name. This is a very powerful option that offers a great deal of flexibility. For example, if you specify the Amazon Web Services account 123456789012 and Mary_Major, all of the following are counted as approvals coming from that user:   An IAM user in the account (arn:aws:iam::123456789012:user/Mary_Major)   A federated user identified in IAM as Mary_Major (arn:aws:sts::123456789012:federated-user/Mary_Major)   This option does not recognize an active session of someone assuming the role of CodeCommitReview with a role session name of Mary_Major (arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you include a wildcard (*Mary_Major).    Fully qualified ARN: This option allows you to specify the fully qualified Amazon Resource Name (ARN) of the IAM user or role.    For more information about IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User Guide.
    ///   - approvalRuleTemplateDescription: The description of the approval rule template. Consider providing a description that explains what this template does and when it might be appropriate to associate it with repositories.
    ///   - approvalRuleTemplateName: The name of the approval rule template. Provide descriptive names, because this name is applied to the approval rules created automatically in associated repositories.
    ///   - logger: Logger use during operation
    @inlinable
    public func createApprovalRuleTemplate(
        approvalRuleTemplateContent: String,
        approvalRuleTemplateDescription: String? = nil,
        approvalRuleTemplateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateApprovalRuleTemplateOutput {
        let input = CreateApprovalRuleTemplateInput(
            approvalRuleTemplateContent: approvalRuleTemplateContent, 
            approvalRuleTemplateDescription: approvalRuleTemplateDescription, 
            approvalRuleTemplateName: approvalRuleTemplateName
        )
        return try await self.createApprovalRuleTemplate(input, logger: logger)
    }

    /// Creates a branch in a repository and points the branch to a commit.  Calling the create branch operation does not set a repository's default branch. To do this, call the update default branch operation.
    @Sendable
    @inlinable
    public func createBranch(_ input: CreateBranchInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "CreateBranch", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a branch in a repository and points the branch to a commit.  Calling the create branch operation does not set a repository's default branch. To do this, call the update default branch operation.
    ///
    /// Parameters:
    ///   - branchName: The name of the new branch to create.
    ///   - commitId: The ID of the commit to point the new branch to.
    ///   - repositoryName: The name of the repository in which you want to create the new branch.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBranch(
        branchName: String,
        commitId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = CreateBranchInput(
            branchName: branchName, 
            commitId: commitId, 
            repositoryName: repositoryName
        )
        return try await self.createBranch(input, logger: logger)
    }

    /// Creates a commit for a repository on the tip of a specified branch.
    @Sendable
    @inlinable
    public func createCommit(_ input: CreateCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCommitOutput {
        try await self.client.execute(
            operation: "CreateCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a commit for a repository on the tip of a specified branch.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the commit. This information is used as both the author and committer for the commit.
    ///   - branchName: The name of the branch where you create the commit.
    ///   - commitMessage: The commit message you want to include in the commit. Commit messages are limited to 256 KB. If no message is specified, a default message is used.
    ///   - deleteFiles: The files to delete in this commit. These files still exist in earlier commits.
    ///   - email: The email address of the person who created the commit.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If true, a ..gitkeep file is created for empty folders. The default is false.
    ///   - parentCommitId: The ID of the commit that is the parent of the commit you create. Not required if this is an empty repository.
    ///   - putFiles: The files to add or update in this commit.
    ///   - repositoryName: The name of the repository where you create the commit.
    ///   - setFileModes: The file modes to update for files in this commit.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCommit(
        authorName: String? = nil,
        branchName: String,
        commitMessage: String? = nil,
        deleteFiles: [DeleteFileEntry]? = nil,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        parentCommitId: String? = nil,
        putFiles: [PutFileEntry]? = nil,
        repositoryName: String,
        setFileModes: [SetFileModeEntry]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCommitOutput {
        let input = CreateCommitInput(
            authorName: authorName, 
            branchName: branchName, 
            commitMessage: commitMessage, 
            deleteFiles: deleteFiles, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            parentCommitId: parentCommitId, 
            putFiles: putFiles, 
            repositoryName: repositoryName, 
            setFileModes: setFileModes
        )
        return try await self.createCommit(input, logger: logger)
    }

    /// Creates a pull request in the specified repository.
    @Sendable
    @inlinable
    public func createPullRequest(_ input: CreatePullRequestInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePullRequestOutput {
        try await self.client.execute(
            operation: "CreatePullRequest", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a pull request in the specified repository.
    ///
    /// Parameters:
    ///   - clientRequestToken: A unique, client-generated idempotency token that, when provided in a request, ensures the request cannot be repeated with a changed parameter. If a request is received with the same parameters and a token is included, the request returns information about the initial request that used that token.  The Amazon Web ServicesSDKs prepopulate client request tokens. If you are using an Amazon Web ServicesSDK, an idempotency token is created for you.
    ///   - description: A description of the pull request.
    ///   - targets: The targets for the pull request, including the source of the code to be reviewed (the source branch) and the destination where the creator of the pull request intends the code to be merged after the pull request is closed (the destination branch).
    ///   - title: The title of the pull request. This title is used to identify the pull request to other users in the repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPullRequest(
        clientRequestToken: String? = CreatePullRequestInput.idempotencyToken(),
        description: String? = nil,
        targets: [Target],
        title: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePullRequestOutput {
        let input = CreatePullRequestInput(
            clientRequestToken: clientRequestToken, 
            description: description, 
            targets: targets, 
            title: title
        )
        return try await self.createPullRequest(input, logger: logger)
    }

    /// Creates an approval rule for a pull request.
    @Sendable
    @inlinable
    public func createPullRequestApprovalRule(_ input: CreatePullRequestApprovalRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePullRequestApprovalRuleOutput {
        try await self.client.execute(
            operation: "CreatePullRequestApprovalRule", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an approval rule for a pull request.
    ///
    /// Parameters:
    ///   - approvalRuleContent: The content of the approval rule, including the number of approvals needed and the structure of an approval pool defined for approvals, if any. For more information about approval pools, see the CodeCommit User Guide.  When you create the content of the approval rule, you can specify approvers in an approval pool in one of two ways:    CodeCommitApprovers: This option only requires an Amazon Web Services account and a resource. It can be used for both IAM users and federated access users whose name matches the provided resource name. This is a very powerful option that offers a great deal of flexibility. For example, if you specify the Amazon Web Services account 123456789012 and Mary_Major, all of the following would be counted as approvals coming from that user:   An IAM user in the account (arn:aws:iam::123456789012:user/Mary_Major)   A federated user identified in IAM as Mary_Major (arn:aws:sts::123456789012:federated-user/Mary_Major)   This option does not recognize an active session of someone assuming the role of CodeCommitReview with a role session name of Mary_Major (arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you include a wildcard (*Mary_Major).    Fully qualified ARN: This option allows you to specify the fully qualified Amazon Resource Name (ARN) of the IAM user or role.    For more information about IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User Guide.
    ///   - approvalRuleName: The name for the approval rule.
    ///   - pullRequestId: The system-generated ID of the pull request for which you want to create the approval rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPullRequestApprovalRule(
        approvalRuleContent: String,
        approvalRuleName: String,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePullRequestApprovalRuleOutput {
        let input = CreatePullRequestApprovalRuleInput(
            approvalRuleContent: approvalRuleContent, 
            approvalRuleName: approvalRuleName, 
            pullRequestId: pullRequestId
        )
        return try await self.createPullRequestApprovalRule(input, logger: logger)
    }

    /// Creates a new, empty repository.
    @Sendable
    @inlinable
    public func createRepository(_ input: CreateRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRepositoryOutput {
        try await self.client.execute(
            operation: "CreateRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new, empty repository.
    ///
    /// Parameters:
    ///   - kmsKeyId: The ID of the encryption key. You can view the ID of an encryption key in the KMS console, or use the KMS APIs to programmatically retrieve a key ID. For more information about acceptable values for kmsKeyID, see  KeyId in the Decrypt API description in  the Key Management Service API Reference. If no key is specified, the default aws/codecommit Amazon Web Services managed key is used.
    ///   - repositoryDescription: A comment or description about the new repository.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    ///   - repositoryName: The name of the new repository to be created.  The repository name must be unique across the calling Amazon Web Services account. Repository names are limited to 100 alphanumeric, dash, and underscore characters, and cannot include certain characters. For more information about the limits on repository names, see Quotas in the CodeCommit User Guide. The suffix .git is prohibited.
    ///   - tags: One or more tag key-value pairs to use when tagging this repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRepository(
        kmsKeyId: String? = nil,
        repositoryDescription: String? = nil,
        repositoryName: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRepositoryOutput {
        let input = CreateRepositoryInput(
            kmsKeyId: kmsKeyId, 
            repositoryDescription: repositoryDescription, 
            repositoryName: repositoryName, 
            tags: tags
        )
        return try await self.createRepository(input, logger: logger)
    }

    /// Creates an unreferenced commit that represents the result of merging two branches using a specified merge strategy. This can help you determine the outcome of a potential merge. This API cannot be used with the fast-forward merge strategy because that strategy does not create a merge commit.  This unreferenced merge commit  can only be accessed using the GetCommit API or through git commands such as git fetch. To retrieve this commit, you must specify its commit ID or otherwise reference it.
    @Sendable
    @inlinable
    public func createUnreferencedMergeCommit(_ input: CreateUnreferencedMergeCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUnreferencedMergeCommitOutput {
        try await self.client.execute(
            operation: "CreateUnreferencedMergeCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an unreferenced commit that represents the result of merging two branches using a specified merge strategy. This can help you determine the outcome of a potential merge. This API cannot be used with the fast-forward merge strategy because that strategy does not create a merge commit.  This unreferenced merge commit  can only be accessed using the GetCommit API or through git commands such as git fetch. To retrieve this commit, you must specify its commit ID or otherwise reference it.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the unreferenced commit. This information is used as both the author and committer for the commit.
    ///   - commitMessage: The commit message for the unreferenced commit.
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolution: If AUTOMERGE is the conflict resolution strategy, a list of inputs to use when resolving conflicts during a merge.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - email: The email address for the person who created the unreferenced commit.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If this is specified as true, a .gitkeep file is created for empty folders. The default is false.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - repositoryName: The name of the repository where you want to create the unreferenced merge commit.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func createUnreferencedMergeCommit(
        authorName: String? = nil,
        commitMessage: String? = nil,
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolution: ConflictResolution? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        mergeOption: MergeOptionTypeEnum,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUnreferencedMergeCommitOutput {
        let input = CreateUnreferencedMergeCommitInput(
            authorName: authorName, 
            commitMessage: commitMessage, 
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolution: conflictResolution, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            mergeOption: mergeOption, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.createUnreferencedMergeCommit(input, logger: logger)
    }

    /// Deletes a specified approval rule template. Deleting a template does not remove approval rules on pull requests already created with the template.
    @Sendable
    @inlinable
    public func deleteApprovalRuleTemplate(_ input: DeleteApprovalRuleTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApprovalRuleTemplateOutput {
        try await self.client.execute(
            operation: "DeleteApprovalRuleTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified approval rule template. Deleting a template does not remove approval rules on pull requests already created with the template.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApprovalRuleTemplate(
        approvalRuleTemplateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApprovalRuleTemplateOutput {
        let input = DeleteApprovalRuleTemplateInput(
            approvalRuleTemplateName: approvalRuleTemplateName
        )
        return try await self.deleteApprovalRuleTemplate(input, logger: logger)
    }

    /// Deletes a branch from a repository, unless that branch is the default branch for the repository.
    @Sendable
    @inlinable
    public func deleteBranch(_ input: DeleteBranchInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBranchOutput {
        try await self.client.execute(
            operation: "DeleteBranch", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a branch from a repository, unless that branch is the default branch for the repository.
    ///
    /// Parameters:
    ///   - branchName: The name of the branch to delete.
    ///   - repositoryName: The name of the repository that contains the branch to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBranch(
        branchName: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBranchOutput {
        let input = DeleteBranchInput(
            branchName: branchName, 
            repositoryName: repositoryName
        )
        return try await self.deleteBranch(input, logger: logger)
    }

    /// Deletes the content of a comment made on a change, file, or commit in a repository.
    @Sendable
    @inlinable
    public func deleteCommentContent(_ input: DeleteCommentContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCommentContentOutput {
        try await self.client.execute(
            operation: "DeleteCommentContent", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the content of a comment made on a change, file, or commit in a repository.
    ///
    /// Parameters:
    ///   - commentId: The unique, system-generated ID of the comment. To get this ID, use  GetCommentsForComparedCommit or GetCommentsForPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCommentContent(
        commentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCommentContentOutput {
        let input = DeleteCommentContentInput(
            commentId: commentId
        )
        return try await self.deleteCommentContent(input, logger: logger)
    }

    /// Deletes a specified file from a specified branch. A commit is created on the branch that contains the revision. The file still exists in the commits earlier to the commit that contains the deletion.
    @Sendable
    @inlinable
    public func deleteFile(_ input: DeleteFileInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFileOutput {
        try await self.client.execute(
            operation: "DeleteFile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a specified file from a specified branch. A commit is created on the branch that contains the revision. The file still exists in the commits earlier to the commit that contains the deletion.
    ///
    /// Parameters:
    ///   - branchName: The name of the branch where the commit that deletes the file is made.
    ///   - commitMessage: The commit message you want to include as part of deleting the file. Commit messages are limited to 256 KB. If no message is specified, a default message is used.
    ///   - email: The email address for the commit that deletes the file. If no email address is specified, the email address is left blank.
    ///   - filePath: The fully qualified path to the file that to be deleted, including the full name and extension of that file. For example, /examples/file.md is a fully qualified path to a file named file.md in a folder named examples.
    ///   - keepEmptyFolders: If a file is the only object in the folder or directory, specifies whether to delete the folder or directory that contains the file. By default, empty folders are deleted. This includes empty folders that are part of the directory structure. For example, if the path to a file is dir1/dir2/dir3/dir4, and dir2 and dir3 are empty, deleting the last file in dir4 also deletes the empty folders dir4, dir3, and dir2.
    ///   - name: The name of the author of the commit that deletes the file. If no name is specified, the user's ARN is used as the author name and committer name.
    ///   - parentCommitId: The ID of the commit that is the tip of the branch where you want to create the commit that deletes the file. This must be the HEAD commit for the branch. The commit that deletes the file is created from this commit ID.
    ///   - repositoryName: The name of the repository that contains the file to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFile(
        branchName: String,
        commitMessage: String? = nil,
        email: String? = nil,
        filePath: String,
        keepEmptyFolders: Bool? = nil,
        name: String? = nil,
        parentCommitId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFileOutput {
        let input = DeleteFileInput(
            branchName: branchName, 
            commitMessage: commitMessage, 
            email: email, 
            filePath: filePath, 
            keepEmptyFolders: keepEmptyFolders, 
            name: name, 
            parentCommitId: parentCommitId, 
            repositoryName: repositoryName
        )
        return try await self.deleteFile(input, logger: logger)
    }

    /// Deletes an approval rule from a specified pull request. Approval rules can be deleted from a pull request only if the pull request is open, and if the  approval rule was created specifically for a pull request and not generated from an approval rule template associated with the repository where the  pull request was created. You cannot delete an approval rule from a merged or closed pull request.
    @Sendable
    @inlinable
    public func deletePullRequestApprovalRule(_ input: DeletePullRequestApprovalRuleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePullRequestApprovalRuleOutput {
        try await self.client.execute(
            operation: "DeletePullRequestApprovalRule", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an approval rule from a specified pull request. Approval rules can be deleted from a pull request only if the pull request is open, and if the  approval rule was created specifically for a pull request and not generated from an approval rule template associated with the repository where the  pull request was created. You cannot delete an approval rule from a merged or closed pull request.
    ///
    /// Parameters:
    ///   - approvalRuleName: The name of the approval rule you want to delete.
    ///   - pullRequestId: The system-generated ID of the pull request that contains the approval rule you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePullRequestApprovalRule(
        approvalRuleName: String,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePullRequestApprovalRuleOutput {
        let input = DeletePullRequestApprovalRuleInput(
            approvalRuleName: approvalRuleName, 
            pullRequestId: pullRequestId
        )
        return try await self.deletePullRequestApprovalRule(input, logger: logger)
    }

    /// Deletes a repository. If a specified repository was already deleted, a null repository ID is returned.  Deleting a repository also deletes all associated objects and metadata. After a repository is deleted, all future push calls to the deleted repository fail.
    @Sendable
    @inlinable
    public func deleteRepository(_ input: DeleteRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRepositoryOutput {
        try await self.client.execute(
            operation: "DeleteRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a repository. If a specified repository was already deleted, a null repository ID is returned.  Deleting a repository also deletes all associated objects and metadata. After a repository is deleted, all future push calls to the deleted repository fail.
    ///
    /// Parameters:
    ///   - repositoryName: The name of the repository to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRepository(
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRepositoryOutput {
        let input = DeleteRepositoryInput(
            repositoryName: repositoryName
        )
        return try await self.deleteRepository(input, logger: logger)
    }

    /// Returns information about one or more merge conflicts in the attempted merge of two commit specifiers using the squash or three-way merge strategy. If the merge option for the attempted merge is specified as FAST_FORWARD_MERGE, an exception is thrown.
    @Sendable
    @inlinable
    public func describeMergeConflicts(_ input: DescribeMergeConflictsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMergeConflictsOutput {
        try await self.client.execute(
            operation: "DescribeMergeConflicts", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about one or more merge conflicts in the attempted merge of two commit specifiers using the squash or three-way merge strategy. If the merge option for the attempted merge is specified as FAST_FORWARD_MERGE, an exception is thrown.
    ///
    /// Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - filePath: The path of the target files used to describe the conflicts.
    ///   - maxMergeHunks: The maximum number of merge hunks to include in the output.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository where you want to get information about a merge conflict.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMergeConflicts(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        filePath: String,
        maxMergeHunks: Int? = nil,
        mergeOption: MergeOptionTypeEnum,
        nextToken: String? = nil,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMergeConflictsOutput {
        let input = DescribeMergeConflictsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            filePath: filePath, 
            maxMergeHunks: maxMergeHunks, 
            mergeOption: mergeOption, 
            nextToken: nextToken, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.describeMergeConflicts(input, logger: logger)
    }

    /// Returns information about one or more pull request events.
    @Sendable
    @inlinable
    public func describePullRequestEvents(_ input: DescribePullRequestEventsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePullRequestEventsOutput {
        try await self.client.execute(
            operation: "DescribePullRequestEvents", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about one or more pull request events.
    ///
    /// Parameters:
    ///   - actorArn: The Amazon Resource Name (ARN) of the user whose actions resulted in the event. Examples include updating the pull request with more commits or changing the status of a pull request.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.  The default is 100 events, which is also the maximum number of events that can be returned in a result.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - pullRequestEventType: Optional. The pull request event type about which you want to return information.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePullRequestEvents(
        actorArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pullRequestEventType: PullRequestEventType? = nil,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePullRequestEventsOutput {
        let input = DescribePullRequestEventsInput(
            actorArn: actorArn, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pullRequestEventType: pullRequestEventType, 
            pullRequestId: pullRequestId
        )
        return try await self.describePullRequestEvents(input, logger: logger)
    }

    /// Removes the association between a template and a repository so that approval rules based on the template are not automatically created when pull requests are created in the specified repository. This does not delete any approval rules previously created for pull requests through the template association.
    @Sendable
    @inlinable
    public func disassociateApprovalRuleTemplateFromRepository(_ input: DisassociateApprovalRuleTemplateFromRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateApprovalRuleTemplateFromRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the association between a template and a repository so that approval rules based on the template are not automatically created when pull requests are created in the specified repository. This does not delete any approval rules previously created for pull requests through the template association.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template to disassociate from a specified repository.
    ///   - repositoryName: The name of the repository you want to disassociate from the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateApprovalRuleTemplateFromRepository(
        approvalRuleTemplateName: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateApprovalRuleTemplateFromRepositoryInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            repositoryName: repositoryName
        )
        return try await self.disassociateApprovalRuleTemplateFromRepository(input, logger: logger)
    }

    /// Evaluates whether a pull request has met all the conditions specified in its associated approval rules.
    @Sendable
    @inlinable
    public func evaluatePullRequestApprovalRules(_ input: EvaluatePullRequestApprovalRulesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> EvaluatePullRequestApprovalRulesOutput {
        try await self.client.execute(
            operation: "EvaluatePullRequestApprovalRules", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Evaluates whether a pull request has met all the conditions specified in its associated approval rules.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID of the pull request you want to evaluate.
    ///   - revisionId: The system-generated ID for the pull request revision. To retrieve the most recent revision ID for a pull request, use GetPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func evaluatePullRequestApprovalRules(
        pullRequestId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EvaluatePullRequestApprovalRulesOutput {
        let input = EvaluatePullRequestApprovalRulesInput(
            pullRequestId: pullRequestId, 
            revisionId: revisionId
        )
        return try await self.evaluatePullRequestApprovalRules(input, logger: logger)
    }

    /// Returns information about a specified approval rule template.
    @Sendable
    @inlinable
    public func getApprovalRuleTemplate(_ input: GetApprovalRuleTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApprovalRuleTemplateOutput {
        try await self.client.execute(
            operation: "GetApprovalRuleTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a specified approval rule template.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template for which you want to get information.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApprovalRuleTemplate(
        approvalRuleTemplateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApprovalRuleTemplateOutput {
        let input = GetApprovalRuleTemplateInput(
            approvalRuleTemplateName: approvalRuleTemplateName
        )
        return try await self.getApprovalRuleTemplate(input, logger: logger)
    }

    /// Returns the base-64 encoded content of an individual blob in a repository.
    @Sendable
    @inlinable
    public func getBlob(_ input: GetBlobInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBlobOutput {
        try await self.client.execute(
            operation: "GetBlob", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the base-64 encoded content of an individual blob in a repository.
    ///
    /// Parameters:
    ///   - blobId: The ID of the blob, which is its SHA-1 pointer.
    ///   - repositoryName: The name of the repository that contains the blob.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBlob(
        blobId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBlobOutput {
        let input = GetBlobInput(
            blobId: blobId, 
            repositoryName: repositoryName
        )
        return try await self.getBlob(input, logger: logger)
    }

    /// Returns information about a repository branch, including its name and the last commit ID.
    @Sendable
    @inlinable
    public func getBranch(_ input: GetBranchInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBranchOutput {
        try await self.client.execute(
            operation: "GetBranch", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a repository branch, including its name and the last commit ID.
    ///
    /// Parameters:
    ///   - branchName: The name of the branch for which you want to retrieve information.
    ///   - repositoryName: The name of the repository that contains the branch for which you want to retrieve information.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBranch(
        branchName: String? = nil,
        repositoryName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBranchOutput {
        let input = GetBranchInput(
            branchName: branchName, 
            repositoryName: repositoryName
        )
        return try await self.getBranch(input, logger: logger)
    }

    /// Returns the content of a comment made on a change, file, or commit in a repository.   Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    @Sendable
    @inlinable
    public func getComment(_ input: GetCommentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCommentOutput {
        try await self.client.execute(
            operation: "GetComment", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the content of a comment made on a change, file, or commit in a repository.   Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    ///
    /// Parameters:
    ///   - commentId: The unique, system-generated ID of the comment. To get this ID, use  GetCommentsForComparedCommit or GetCommentsForPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func getComment(
        commentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCommentOutput {
        let input = GetCommentInput(
            commentId: commentId
        )
        return try await self.getComment(input, logger: logger)
    }

    /// Returns information about reactions to a specified comment ID. Reactions from users who have been deleted will not be included in the count.
    @Sendable
    @inlinable
    public func getCommentReactions(_ input: GetCommentReactionsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCommentReactionsOutput {
        try await self.client.execute(
            operation: "GetCommentReactions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about reactions to a specified comment ID. Reactions from users who have been deleted will not be included in the count.
    ///
    /// Parameters:
    ///   - commentId: The ID of the comment for which you want to get reactions information.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.  The default is the same as the allowed maximum, 1,000.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - reactionUserArn: Optional. The Amazon Resource Name (ARN) of the user or identity for which you want to get reaction information.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCommentReactions(
        commentId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        reactionUserArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCommentReactionsOutput {
        let input = GetCommentReactionsInput(
            commentId: commentId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            reactionUserArn: reactionUserArn
        )
        return try await self.getCommentReactions(input, logger: logger)
    }

    /// Returns information about comments made on the comparison between two commits.  Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    @Sendable
    @inlinable
    public func getCommentsForComparedCommit(_ input: GetCommentsForComparedCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCommentsForComparedCommitOutput {
        try await self.client.execute(
            operation: "GetCommentsForComparedCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about comments made on the comparison between two commits.  Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    ///
    /// Parameters:
    ///   - afterCommitId: To establish the directionality of the comparison, the full commit ID of the after commit.
    ///   - beforeCommitId: To establish the directionality of the comparison, the full commit ID of the before commit.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results. The default is 100 comments, but you can configure up to 500.
    ///   - nextToken: An enumeration token that when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository where you want to compare commits.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCommentsForComparedCommit(
        afterCommitId: String,
        beforeCommitId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCommentsForComparedCommitOutput {
        let input = GetCommentsForComparedCommitInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            repositoryName: repositoryName
        )
        return try await self.getCommentsForComparedCommit(input, logger: logger)
    }

    /// Returns comments made on a pull request.  Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    @Sendable
    @inlinable
    public func getCommentsForPullRequest(_ input: GetCommentsForPullRequestInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCommentsForPullRequestOutput {
        try await self.client.execute(
            operation: "GetCommentsForPullRequest", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns comments made on a pull request.  Reaction counts might include numbers from user identities who were deleted after the reaction was made. For a count of  reactions from active identities, use GetCommentReactions.
    ///
    /// Parameters:
    ///   - afterCommitId: The full commit ID of the commit in the source branch that was the tip of the branch at the time the comment was made. Requirement is conditional:  afterCommitId must be specified when repositoryName is included.
    ///   - beforeCommitId: The full commit ID of the commit in the destination branch that was the tip of the branch at the time the pull request was created. Requirement is conditional:  beforeCommitId must be specified when repositoryName is included.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results. The default is 100 comments. You can return up to 500 comments with a single request.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository that contains the pull request. Requirement is conditional: repositoryName must be specified when  beforeCommitId and afterCommitId are included.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCommentsForPullRequest(
        afterCommitId: String? = nil,
        beforeCommitId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pullRequestId: String,
        repositoryName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCommentsForPullRequestOutput {
        let input = GetCommentsForPullRequestInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName
        )
        return try await self.getCommentsForPullRequest(input, logger: logger)
    }

    /// Returns information about a commit, including commit message and committer information.
    @Sendable
    @inlinable
    public func getCommit(_ input: GetCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCommitOutput {
        try await self.client.execute(
            operation: "GetCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a commit, including commit message and committer information.
    ///
    /// Parameters:
    ///   - commitId: The commit ID. Commit IDs are the full SHA ID of the commit.
    ///   - repositoryName: The name of the repository to which the commit was made.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCommit(
        commitId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCommitOutput {
        let input = GetCommitInput(
            commitId: commitId, 
            repositoryName: repositoryName
        )
        return try await self.getCommit(input, logger: logger)
    }

    /// Returns information about the differences in a valid commit specifier (such as a branch, tag, HEAD, commit ID, or other fully qualified reference). Results can be limited to a specified path.
    @Sendable
    @inlinable
    public func getDifferences(_ input: GetDifferencesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDifferencesOutput {
        try await self.client.execute(
            operation: "GetDifferences", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the differences in a valid commit specifier (such as a branch, tag, HEAD, commit ID, or other fully qualified reference). Results can be limited to a specified path.
    ///
    /// Parameters:
    ///   - afterCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit.
    ///   - afterPath: The file path in which to check differences. Limits the results to this path. Can also be used to specify the changed name of a directory or folder, if it has changed. If not specified, differences are shown for all paths.
    ///   - beforeCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, the full commit ID). Optional. If not specified, all changes before the afterCommitSpecifier value are shown. If you do not use beforeCommitSpecifier in your request, consider limiting the results with maxResults.
    ///   - beforePath: The file path in which to check for differences. Limits the results to this path. Can also be used to specify the previous name of a directory or folder. If beforePath and afterPath are not specified, differences are shown for all paths.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository where you want to get differences.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDifferences(
        afterCommitSpecifier: String,
        afterPath: String? = nil,
        beforeCommitSpecifier: String? = nil,
        beforePath: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDifferencesOutput {
        let input = GetDifferencesInput(
            afterCommitSpecifier: afterCommitSpecifier, 
            afterPath: afterPath, 
            beforeCommitSpecifier: beforeCommitSpecifier, 
            beforePath: beforePath, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            repositoryName: repositoryName
        )
        return try await self.getDifferences(input, logger: logger)
    }

    /// Returns the base-64 encoded contents of a specified file and its metadata.
    @Sendable
    @inlinable
    public func getFile(_ input: GetFileInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFileOutput {
        try await self.client.execute(
            operation: "GetFile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the base-64 encoded contents of a specified file and its metadata.
    ///
    /// Parameters:
    ///   - commitSpecifier: The fully quaified reference that identifies the commit that contains the file. For example, you can specify a full commit ID, a tag, a branch name, or a reference such as refs/heads/main. If none is provided, the head commit is used.
    ///   - filePath: The fully qualified path to the file, including the full name and extension of the file. For example, /examples/file.md is the fully qualified path to a file named file.md in a folder named examples.
    ///   - repositoryName: The name of the repository that contains the file.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFile(
        commitSpecifier: String? = nil,
        filePath: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFileOutput {
        let input = GetFileInput(
            commitSpecifier: commitSpecifier, 
            filePath: filePath, 
            repositoryName: repositoryName
        )
        return try await self.getFile(input, logger: logger)
    }

    /// Returns the contents of a specified folder in a repository.
    @Sendable
    @inlinable
    public func getFolder(_ input: GetFolderInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFolderOutput {
        try await self.client.execute(
            operation: "GetFolder", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the contents of a specified folder in a repository.
    ///
    /// Parameters:
    ///   - commitSpecifier: A fully qualified reference used to identify a commit that contains the version of the folder's content to return. A fully qualified reference can be a commit ID, branch name, tag, or reference such as HEAD. If no specifier is provided, the folder content is returned as it exists in the HEAD commit.
    ///   - folderPath: The fully qualified path to the folder whose contents are returned, including the folder name. For example, /examples is a fully-qualified path to a folder named examples that was created off of the root directory (/) of a repository.
    ///   - repositoryName: The name of the repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFolder(
        commitSpecifier: String? = nil,
        folderPath: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFolderOutput {
        let input = GetFolderInput(
            commitSpecifier: commitSpecifier, 
            folderPath: folderPath, 
            repositoryName: repositoryName
        )
        return try await self.getFolder(input, logger: logger)
    }

    /// Returns information about a specified merge commit.
    @Sendable
    @inlinable
    public func getMergeCommit(_ input: GetMergeCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMergeCommitOutput {
        try await self.client.execute(
            operation: "GetMergeCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a specified merge commit.
    ///
    /// Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - repositoryName: The name of the repository that contains the merge commit about which you want to get information.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func getMergeCommit(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMergeCommitOutput {
        let input = GetMergeCommitInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.getMergeCommit(input, logger: logger)
    }

    /// Returns information about merge conflicts between the before and after commit IDs for a pull request in a repository.
    @Sendable
    @inlinable
    public func getMergeConflicts(_ input: GetMergeConflictsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMergeConflictsOutput {
        try await self.client.execute(
            operation: "GetMergeConflicts", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about merge conflicts between the before and after commit IDs for a pull request in a repository.
    ///
    /// Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - maxConflictFiles: The maximum number of files to include in the output.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository where the pull request was created.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func getMergeConflicts(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        maxConflictFiles: Int? = nil,
        mergeOption: MergeOptionTypeEnum,
        nextToken: String? = nil,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMergeConflictsOutput {
        let input = GetMergeConflictsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            maxConflictFiles: maxConflictFiles, 
            mergeOption: mergeOption, 
            nextToken: nextToken, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.getMergeConflicts(input, logger: logger)
    }

    /// Returns information about the merge options available for merging two specified branches. For details about why a merge option is not available, use GetMergeConflicts or DescribeMergeConflicts.
    @Sendable
    @inlinable
    public func getMergeOptions(_ input: GetMergeOptionsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMergeOptionsOutput {
        try await self.client.execute(
            operation: "GetMergeOptions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the merge options available for merging two specified branches. For details about why a merge option is not available, use GetMergeConflicts or DescribeMergeConflicts.
    ///
    /// Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - repositoryName: The name of the repository that contains the commits about which you want to get merge options.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger use during operation
    @inlinable
    public func getMergeOptions(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMergeOptionsOutput {
        let input = GetMergeOptionsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return try await self.getMergeOptions(input, logger: logger)
    }

    /// Gets information about a pull request in a specified repository.
    @Sendable
    @inlinable
    public func getPullRequest(_ input: GetPullRequestInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPullRequestOutput {
        try await self.client.execute(
            operation: "GetPullRequest", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a pull request in a specified repository.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPullRequest(
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPullRequestOutput {
        let input = GetPullRequestInput(
            pullRequestId: pullRequestId
        )
        return try await self.getPullRequest(input, logger: logger)
    }

    /// Gets information about the approval states for a specified pull request. Approval states only apply to pull requests that have one or more approval rules applied to them.
    @Sendable
    @inlinable
    public func getPullRequestApprovalStates(_ input: GetPullRequestApprovalStatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPullRequestApprovalStatesOutput {
        try await self.client.execute(
            operation: "GetPullRequestApprovalStates", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the approval states for a specified pull request. Approval states only apply to pull requests that have one or more approval rules applied to them.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID for the pull request.
    ///   - revisionId: The system-generated ID for the pull request revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPullRequestApprovalStates(
        pullRequestId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPullRequestApprovalStatesOutput {
        let input = GetPullRequestApprovalStatesInput(
            pullRequestId: pullRequestId, 
            revisionId: revisionId
        )
        return try await self.getPullRequestApprovalStates(input, logger: logger)
    }

    /// Returns information about whether approval rules have been set aside (overridden) for a  pull request, and if so, the Amazon Resource Name (ARN) of the user or identity that overrode the rules and their requirements for the pull request.
    @Sendable
    @inlinable
    public func getPullRequestOverrideState(_ input: GetPullRequestOverrideStateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPullRequestOverrideStateOutput {
        try await self.client.execute(
            operation: "GetPullRequestOverrideState", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about whether approval rules have been set aside (overridden) for a  pull request, and if so, the Amazon Resource Name (ARN) of the user or identity that overrode the rules and their requirements for the pull request.
    ///
    /// Parameters:
    ///   - pullRequestId: The ID of the pull request for which you want to get information about whether approval rules have been set aside (overridden).
    ///   - revisionId: The system-generated ID of the revision for the pull request. To retrieve the most recent revision ID, use GetPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPullRequestOverrideState(
        pullRequestId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPullRequestOverrideStateOutput {
        let input = GetPullRequestOverrideStateInput(
            pullRequestId: pullRequestId, 
            revisionId: revisionId
        )
        return try await self.getPullRequestOverrideState(input, logger: logger)
    }

    /// Returns information about a repository.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    @Sendable
    @inlinable
    public func getRepository(_ input: GetRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRepositoryOutput {
        try await self.client.execute(
            operation: "GetRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a repository.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    ///
    /// Parameters:
    ///   - repositoryName: The name of the repository to get information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRepository(
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRepositoryOutput {
        let input = GetRepositoryInput(
            repositoryName: repositoryName
        )
        return try await self.getRepository(input, logger: logger)
    }

    /// Gets information about triggers configured for a repository.
    @Sendable
    @inlinable
    public func getRepositoryTriggers(_ input: GetRepositoryTriggersInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRepositoryTriggersOutput {
        try await self.client.execute(
            operation: "GetRepositoryTriggers", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about triggers configured for a repository.
    ///
    /// Parameters:
    ///   - repositoryName: The name of the repository for which the trigger is configured.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRepositoryTriggers(
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRepositoryTriggersOutput {
        let input = GetRepositoryTriggersInput(
            repositoryName: repositoryName
        )
        return try await self.getRepositoryTriggers(input, logger: logger)
    }

    /// Lists all approval rule templates in the specified Amazon Web Services Region in your Amazon Web Services account. If an Amazon Web Services Region is not specified, the Amazon Web Services Region where you are signed in is used.
    @Sendable
    @inlinable
    public func listApprovalRuleTemplates(_ input: ListApprovalRuleTemplatesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListApprovalRuleTemplatesOutput {
        try await self.client.execute(
            operation: "ListApprovalRuleTemplates", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all approval rule templates in the specified Amazon Web Services Region in your Amazon Web Services account. If an Amazon Web Services Region is not specified, the Amazon Web Services Region where you are signed in is used.
    ///
    /// Parameters:
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listApprovalRuleTemplates(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListApprovalRuleTemplatesOutput {
        let input = ListApprovalRuleTemplatesInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listApprovalRuleTemplates(input, logger: logger)
    }

    /// Lists all approval rule templates that are associated with a specified repository.
    @Sendable
    @inlinable
    public func listAssociatedApprovalRuleTemplatesForRepository(_ input: ListAssociatedApprovalRuleTemplatesForRepositoryInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssociatedApprovalRuleTemplatesForRepositoryOutput {
        try await self.client.execute(
            operation: "ListAssociatedApprovalRuleTemplatesForRepository", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all approval rule templates that are associated with a specified repository.
    ///
    /// Parameters:
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - repositoryName: The name of the repository for which you want to list all associated approval rule templates.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssociatedApprovalRuleTemplatesForRepository(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssociatedApprovalRuleTemplatesForRepositoryOutput {
        let input = ListAssociatedApprovalRuleTemplatesForRepositoryInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            repositoryName: repositoryName
        )
        return try await self.listAssociatedApprovalRuleTemplatesForRepository(input, logger: logger)
    }

    /// Gets information about one or more branches in a repository.
    @Sendable
    @inlinable
    public func listBranches(_ input: ListBranchesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBranchesOutput {
        try await self.client.execute(
            operation: "ListBranches", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more branches in a repository.
    ///
    /// Parameters:
    ///   - nextToken: An enumeration token that allows the operation to batch the results.
    ///   - repositoryName: The name of the repository that contains the branches.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBranches(
        nextToken: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBranchesOutput {
        let input = ListBranchesInput(
            nextToken: nextToken, 
            repositoryName: repositoryName
        )
        return try await self.listBranches(input, logger: logger)
    }

    /// Retrieves a list of commits and changes to a specified file.
    @Sendable
    @inlinable
    public func listFileCommitHistory(_ input: ListFileCommitHistoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFileCommitHistoryResponse {
        try await self.client.execute(
            operation: "ListFileCommitHistory", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of commits and changes to a specified file.
    ///
    /// Parameters:
    ///   - commitSpecifier: The fully quaified reference that identifies the commit that contains the file. For example, you can specify a full commit ID, a tag, a branch name, or a reference such as refs/heads/main. If none is provided, the head commit is used.
    ///   - filePath: The full path of the file whose history you want to retrieve, including the name of the file.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that allows the operation to batch the results.
    ///   - repositoryName: The name of the repository that contains the file.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFileCommitHistory(
        commitSpecifier: String? = nil,
        filePath: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFileCommitHistoryResponse {
        let input = ListFileCommitHistoryRequest(
            commitSpecifier: commitSpecifier, 
            filePath: filePath, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            repositoryName: repositoryName
        )
        return try await self.listFileCommitHistory(input, logger: logger)
    }

    /// Returns a list of pull requests for a specified repository. The return list can be refined by pull request  status or pull request author ARN.
    @Sendable
    @inlinable
    public func listPullRequests(_ input: ListPullRequestsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPullRequestsOutput {
        try await self.client.execute(
            operation: "ListPullRequests", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of pull requests for a specified repository. The return list can be refined by pull request  status or pull request author ARN.
    ///
    /// Parameters:
    ///   - authorArn: Optional. The Amazon Resource Name (ARN) of the user who created the pull request. If used, this filters the results  to pull requests created by that user.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - pullRequestStatus: Optional. The status of the pull request. If used, this refines the results to the pull requests that match the specified status.
    ///   - repositoryName: The name of the repository for which you want to list pull requests.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPullRequests(
        authorArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        pullRequestStatus: PullRequestStatusEnum? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPullRequestsOutput {
        let input = ListPullRequestsInput(
            authorArn: authorArn, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            pullRequestStatus: pullRequestStatus, 
            repositoryName: repositoryName
        )
        return try await self.listPullRequests(input, logger: logger)
    }

    /// Gets information about one or more repositories.
    @Sendable
    @inlinable
    public func listRepositories(_ input: ListRepositoriesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRepositoriesOutput {
        try await self.client.execute(
            operation: "ListRepositories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more repositories.
    ///
    /// Parameters:
    ///   - nextToken: An enumeration token that allows the operation to batch the results of the operation.  Batch sizes are 1,000 for list repository operations. When the client sends the token back to CodeCommit, another page of 1,000 records is retrieved.
    ///   - order: The order in which to sort the results of a list repositories operation.
    ///   - sortBy: The criteria used to sort the results of a list repositories operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRepositories(
        nextToken: String? = nil,
        order: OrderEnum? = nil,
        sortBy: SortByEnum? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRepositoriesOutput {
        let input = ListRepositoriesInput(
            nextToken: nextToken, 
            order: order, 
            sortBy: sortBy
        )
        return try await self.listRepositories(input, logger: logger)
    }

    /// Lists all repositories associated with the specified approval rule template.
    @Sendable
    @inlinable
    public func listRepositoriesForApprovalRuleTemplate(_ input: ListRepositoriesForApprovalRuleTemplateInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRepositoriesForApprovalRuleTemplateOutput {
        try await self.client.execute(
            operation: "ListRepositoriesForApprovalRuleTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all repositories associated with the specified approval rule template.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template for which you want to list repositories that are associated with that template.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRepositoriesForApprovalRuleTemplate(
        approvalRuleTemplateName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRepositoriesForApprovalRuleTemplateOutput {
        let input = ListRepositoriesForApprovalRuleTemplateInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listRepositoriesForApprovalRuleTemplate(input, logger: logger)
    }

    /// Gets information about Amazon Web Servicestags for a specified Amazon Resource Name (ARN) in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceOutput {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about Amazon Web Servicestags for a specified Amazon Resource Name (ARN) in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    ///
    /// Parameters:
    ///   - nextToken: An enumeration token that, when provided in a request, returns the next batch of the results.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource for which you want to get information about tags, if any.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        nextToken: String? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceOutput {
        let input = ListTagsForResourceInput(
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Merges two branches using the fast-forward merge strategy.
    @Sendable
    @inlinable
    public func mergeBranchesByFastForward(_ input: MergeBranchesByFastForwardInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergeBranchesByFastForwardOutput {
        try await self.client.execute(
            operation: "MergeBranchesByFastForward", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Merges two branches using the fast-forward merge strategy.
    ///
    /// Parameters:
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - repositoryName: The name of the repository where you want to merge two branches.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - targetBranch: The branch where the merge is applied.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergeBranchesByFastForward(
        destinationCommitSpecifier: String,
        repositoryName: String,
        sourceCommitSpecifier: String,
        targetBranch: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergeBranchesByFastForwardOutput {
        let input = MergeBranchesByFastForwardInput(
            destinationCommitSpecifier: destinationCommitSpecifier, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier, 
            targetBranch: targetBranch
        )
        return try await self.mergeBranchesByFastForward(input, logger: logger)
    }

    /// Merges two branches using the squash merge strategy.
    @Sendable
    @inlinable
    public func mergeBranchesBySquash(_ input: MergeBranchesBySquashInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergeBranchesBySquashOutput {
        try await self.client.execute(
            operation: "MergeBranchesBySquash", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Merges two branches using the squash merge strategy.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the commit. This information is used as both the author and committer for the commit.
    ///   - commitMessage: The commit message for the merge.
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolution: If AUTOMERGE is the conflict resolution strategy, a list of inputs to use when resolving conflicts during a merge.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - email: The email address of the person merging the branches. This information is used in the commit information for the merge.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If this is specified as true, a .gitkeep file is created for empty folders. The default is false.
    ///   - repositoryName: The name of the repository where you want to merge two branches.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - targetBranch: The branch where the merge is applied.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergeBranchesBySquash(
        authorName: String? = nil,
        commitMessage: String? = nil,
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolution: ConflictResolution? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        repositoryName: String,
        sourceCommitSpecifier: String,
        targetBranch: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergeBranchesBySquashOutput {
        let input = MergeBranchesBySquashInput(
            authorName: authorName, 
            commitMessage: commitMessage, 
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolution: conflictResolution, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier, 
            targetBranch: targetBranch
        )
        return try await self.mergeBranchesBySquash(input, logger: logger)
    }

    /// Merges two specified branches using the three-way merge strategy.
    @Sendable
    @inlinable
    public func mergeBranchesByThreeWay(_ input: MergeBranchesByThreeWayInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergeBranchesByThreeWayOutput {
        try await self.client.execute(
            operation: "MergeBranchesByThreeWay", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Merges two specified branches using the three-way merge strategy.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the commit. This information is used as both the author and committer for the commit.
    ///   - commitMessage: The commit message to include in the commit information for the merge.
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolution: If AUTOMERGE is the conflict resolution strategy, a list of inputs to use when resolving conflicts during a merge.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - email: The email address of the person merging the branches. This information is used in the commit information for the merge.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If true, a .gitkeep file is created for empty folders. The default is false.
    ///   - repositoryName: The name of the repository where you want to merge two branches.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - targetBranch: The branch where the merge is applied.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergeBranchesByThreeWay(
        authorName: String? = nil,
        commitMessage: String? = nil,
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolution: ConflictResolution? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        repositoryName: String,
        sourceCommitSpecifier: String,
        targetBranch: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergeBranchesByThreeWayOutput {
        let input = MergeBranchesByThreeWayInput(
            authorName: authorName, 
            commitMessage: commitMessage, 
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolution: conflictResolution, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier, 
            targetBranch: targetBranch
        )
        return try await self.mergeBranchesByThreeWay(input, logger: logger)
    }

    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the fast-forward merge strategy. If the merge is successful, it closes the pull request.
    @Sendable
    @inlinable
    public func mergePullRequestByFastForward(_ input: MergePullRequestByFastForwardInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergePullRequestByFastForwardOutput {
        try await self.client.execute(
            operation: "MergePullRequestByFastForward", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the fast-forward merge strategy. If the merge is successful, it closes the pull request.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository where the pull request was created.
    ///   - sourceCommitId: The full commit ID of the original or updated commit in the pull request source branch. Pass this value if you want an  exception thrown if the current commit ID of the tip of the source branch does not match this commit ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergePullRequestByFastForward(
        pullRequestId: String,
        repositoryName: String,
        sourceCommitId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergePullRequestByFastForwardOutput {
        let input = MergePullRequestByFastForwardInput(
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName, 
            sourceCommitId: sourceCommitId
        )
        return try await self.mergePullRequestByFastForward(input, logger: logger)
    }

    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the squash merge strategy. If the merge is successful, it closes the pull request.
    @Sendable
    @inlinable
    public func mergePullRequestBySquash(_ input: MergePullRequestBySquashInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergePullRequestBySquashOutput {
        try await self.client.execute(
            operation: "MergePullRequestBySquash", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the squash merge strategy. If the merge is successful, it closes the pull request.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the commit. This information is used as both the author and committer for the commit.
    ///   - commitMessage: The commit message to include in the commit information for the merge.
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolution: If AUTOMERGE is the conflict resolution strategy, a list of inputs to use when resolving conflicts during a merge.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - email: The email address of the person merging the branches. This information is used in the commit information for the merge.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If true, a .gitkeep file is created for empty folders. The default is false.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository where the pull request was created.
    ///   - sourceCommitId: The full commit ID of the original or updated commit in the pull request source branch. Pass this value if you want an  exception thrown if the current commit ID of the tip of the source branch does not match this commit ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergePullRequestBySquash(
        authorName: String? = nil,
        commitMessage: String? = nil,
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolution: ConflictResolution? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        pullRequestId: String,
        repositoryName: String,
        sourceCommitId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergePullRequestBySquashOutput {
        let input = MergePullRequestBySquashInput(
            authorName: authorName, 
            commitMessage: commitMessage, 
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolution: conflictResolution, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName, 
            sourceCommitId: sourceCommitId
        )
        return try await self.mergePullRequestBySquash(input, logger: logger)
    }

    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the three-way merge strategy. If the merge is successful, it closes the pull request.
    @Sendable
    @inlinable
    public func mergePullRequestByThreeWay(_ input: MergePullRequestByThreeWayInput, logger: Logger = AWSClient.loggingDisabled) async throws -> MergePullRequestByThreeWayOutput {
        try await self.client.execute(
            operation: "MergePullRequestByThreeWay", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attempts to merge the source commit of a pull request into the specified destination branch for that pull request at the specified commit using the three-way merge strategy. If the merge is successful, it closes the pull request.
    ///
    /// Parameters:
    ///   - authorName: The name of the author who created the commit. This information is used as both the author and committer for the commit.
    ///   - commitMessage: The commit message to include in the commit information for the merge.
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolution: If AUTOMERGE is the conflict resolution strategy, a list of inputs to use when resolving conflicts during a merge.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - email: The email address of the person merging the branches. This information is used in the commit information for the merge.
    ///   - keepEmptyFolders: If the commit contains deletions, whether to keep a folder or folder structure if the changes leave the folders empty. If true, a .gitkeep file is created for empty folders. The default is false.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository where the pull request was created.
    ///   - sourceCommitId: The full commit ID of the original or updated commit in the pull request source branch. Pass this value if you want an  exception thrown if the current commit ID of the tip of the source branch does not match this commit ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func mergePullRequestByThreeWay(
        authorName: String? = nil,
        commitMessage: String? = nil,
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolution: ConflictResolution? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        email: String? = nil,
        keepEmptyFolders: Bool? = nil,
        pullRequestId: String,
        repositoryName: String,
        sourceCommitId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MergePullRequestByThreeWayOutput {
        let input = MergePullRequestByThreeWayInput(
            authorName: authorName, 
            commitMessage: commitMessage, 
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolution: conflictResolution, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            email: email, 
            keepEmptyFolders: keepEmptyFolders, 
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName, 
            sourceCommitId: sourceCommitId
        )
        return try await self.mergePullRequestByThreeWay(input, logger: logger)
    }

    /// Sets aside (overrides) all approval rule requirements for a specified pull request.
    @Sendable
    @inlinable
    public func overridePullRequestApprovalRules(_ input: OverridePullRequestApprovalRulesInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "OverridePullRequestApprovalRules", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets aside (overrides) all approval rule requirements for a specified pull request.
    ///
    /// Parameters:
    ///   - overrideStatus: Whether you want to set aside approval rule requirements for the pull request (OVERRIDE) or revoke a previous override and apply  approval rule requirements (REVOKE). REVOKE status is not stored.
    ///   - pullRequestId: The system-generated ID of the pull request for which you want to override all approval rule requirements. To get this information, use GetPullRequest.
    ///   - revisionId: The system-generated ID of the most recent revision of the pull request. You cannot override approval rules for anything but the most recent revision of a pull request. To get the revision ID, use GetPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func overridePullRequestApprovalRules(
        overrideStatus: OverrideStatus,
        pullRequestId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = OverridePullRequestApprovalRulesInput(
            overrideStatus: overrideStatus, 
            pullRequestId: pullRequestId, 
            revisionId: revisionId
        )
        return try await self.overridePullRequestApprovalRules(input, logger: logger)
    }

    /// Posts a comment on the comparison between two commits.
    @Sendable
    @inlinable
    public func postCommentForComparedCommit(_ input: PostCommentForComparedCommitInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PostCommentForComparedCommitOutput {
        try await self.client.execute(
            operation: "PostCommentForComparedCommit", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Posts a comment on the comparison between two commits.
    ///
    /// Parameters:
    ///   - afterCommitId: To establish the directionality of the comparison, the full commit ID of the after commit.
    ///   - beforeCommitId: To establish the directionality of the comparison, the full commit ID of the before commit. Required for commenting on any commit unless that commit is the initial commit.
    ///   - clientRequestToken: A unique, client-generated idempotency token that, when provided in a request, ensures the request cannot be repeated with a changed parameter. If a request is received with the same parameters and a token is included, the request returns information about the initial request that used that token.
    ///   - content: The content of the comment you want to make.
    ///   - location: The location of the comparison where you want to comment.
    ///   - repositoryName: The name of the repository where you want to post a comment on the comparison between commits.
    ///   - logger: Logger use during operation
    @inlinable
    public func postCommentForComparedCommit(
        afterCommitId: String,
        beforeCommitId: String? = nil,
        clientRequestToken: String? = PostCommentForComparedCommitInput.idempotencyToken(),
        content: String,
        location: Location? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PostCommentForComparedCommitOutput {
        let input = PostCommentForComparedCommitInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            clientRequestToken: clientRequestToken, 
            content: content, 
            location: location, 
            repositoryName: repositoryName
        )
        return try await self.postCommentForComparedCommit(input, logger: logger)
    }

    /// Posts a comment on a pull request.
    @Sendable
    @inlinable
    public func postCommentForPullRequest(_ input: PostCommentForPullRequestInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PostCommentForPullRequestOutput {
        try await self.client.execute(
            operation: "PostCommentForPullRequest", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Posts a comment on a pull request.
    ///
    /// Parameters:
    ///   - afterCommitId: The full commit ID of the commit in the source branch that is the current tip of the branch for the pull request when you post the comment.
    ///   - beforeCommitId: The full commit ID of the commit in the destination branch that was the tip of the branch at the time the pull request was created.
    ///   - clientRequestToken: A unique, client-generated idempotency token that, when provided in a request, ensures the request cannot be repeated with a changed parameter. If a request is received with the same parameters and a token is included, the request returns information about the initial request that used that token.
    ///   - content: The content of your comment on the change.
    ///   - location: The location of the change where you want to post your comment. If no location is provided, the comment is posted as a general comment on the pull request difference between the before commit ID and the after commit ID.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository where you want to post a comment on a pull request.
    ///   - logger: Logger use during operation
    @inlinable
    public func postCommentForPullRequest(
        afterCommitId: String,
        beforeCommitId: String,
        clientRequestToken: String? = PostCommentForPullRequestInput.idempotencyToken(),
        content: String,
        location: Location? = nil,
        pullRequestId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PostCommentForPullRequestOutput {
        let input = PostCommentForPullRequestInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            clientRequestToken: clientRequestToken, 
            content: content, 
            location: location, 
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName
        )
        return try await self.postCommentForPullRequest(input, logger: logger)
    }

    /// Posts a comment in reply to an existing comment on a comparison between commits or a pull request.
    @Sendable
    @inlinable
    public func postCommentReply(_ input: PostCommentReplyInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PostCommentReplyOutput {
        try await self.client.execute(
            operation: "PostCommentReply", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Posts a comment in reply to an existing comment on a comparison between commits or a pull request.
    ///
    /// Parameters:
    ///   - clientRequestToken: A unique, client-generated idempotency token that, when provided in a request, ensures the request cannot be repeated with a changed parameter. If a request is received with the same parameters and a token is included, the request returns information about the initial request that used that token.
    ///   - content: The contents of your reply to a comment.
    ///   - inReplyTo: The system-generated ID of the comment to which you want to reply. To get this ID, use GetCommentsForComparedCommit  or GetCommentsForPullRequest.
    ///   - logger: Logger use during operation
    @inlinable
    public func postCommentReply(
        clientRequestToken: String? = PostCommentReplyInput.idempotencyToken(),
        content: String,
        inReplyTo: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PostCommentReplyOutput {
        let input = PostCommentReplyInput(
            clientRequestToken: clientRequestToken, 
            content: content, 
            inReplyTo: inReplyTo
        )
        return try await self.postCommentReply(input, logger: logger)
    }

    /// Adds or updates a reaction to a specified comment for the user whose identity is used to make the request. You can only add or update a reaction for yourself. You cannot add, modify, or delete a reaction for another user.
    @Sendable
    @inlinable
    public func putCommentReaction(_ input: PutCommentReactionInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutCommentReaction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates a reaction to a specified comment for the user whose identity is used to make the request. You can only add or update a reaction for yourself. You cannot add, modify, or delete a reaction for another user.
    ///
    /// Parameters:
    ///   - commentId: The ID of the comment to which you want to add or update a reaction.
    ///   - reactionValue: The emoji reaction you want to add or update. To remove a reaction, provide a value of blank or null. You can also provide the value of none. For information about emoji reaction values supported in CodeCommit, see the CodeCommit User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func putCommentReaction(
        commentId: String,
        reactionValue: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutCommentReactionInput(
            commentId: commentId, 
            reactionValue: reactionValue
        )
        return try await self.putCommentReaction(input, logger: logger)
    }

    /// Adds or updates a file in a branch in an CodeCommit repository, and generates a commit for the addition in the specified branch.
    @Sendable
    @inlinable
    public func putFile(_ input: PutFileInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PutFileOutput {
        try await self.client.execute(
            operation: "PutFile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates a file in a branch in an CodeCommit repository, and generates a commit for the addition in the specified branch.
    ///
    /// Parameters:
    ///   - branchName: The name of the branch where you want to add or update the file. If this is an empty repository, this branch is created.
    ///   - commitMessage: A message about why this file was added or updated. Although it is optional, a message makes the commit history for your repository more useful.
    ///   - email: An email address for the person adding or updating the file.
    ///   - fileContent: The content of the file, in binary object format.
    ///   - fileMode: The file mode permissions of the blob. Valid file mode permissions are listed here.
    ///   - filePath: The name of the file you want to add or update, including the relative path to the file in the repository.  If the path does not currently exist in the repository, the path is created as part of adding the file.
    ///   - name: The name of the person adding or updating the file. Although it is optional, a name makes the commit history for your repository more useful.
    ///   - parentCommitId: The full commit ID of the head commit in the branch where you want to add or update the file. If this is an empty repository,  no commit ID is required. If this is not an empty repository, a commit ID is required.  The commit ID must match the ID of the head commit at the time of the operation. Otherwise, an error occurs, and the file is not added or updated.
    ///   - repositoryName: The name of the repository where you want to add or update the file.
    ///   - logger: Logger use during operation
    @inlinable
    public func putFile(
        branchName: String,
        commitMessage: String? = nil,
        email: String? = nil,
        fileContent: AWSBase64Data,
        fileMode: FileModeTypeEnum? = nil,
        filePath: String,
        name: String? = nil,
        parentCommitId: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutFileOutput {
        let input = PutFileInput(
            branchName: branchName, 
            commitMessage: commitMessage, 
            email: email, 
            fileContent: fileContent, 
            fileMode: fileMode, 
            filePath: filePath, 
            name: name, 
            parentCommitId: parentCommitId, 
            repositoryName: repositoryName
        )
        return try await self.putFile(input, logger: logger)
    }

    /// Replaces all triggers for a repository. Used to create or delete triggers.
    @Sendable
    @inlinable
    public func putRepositoryTriggers(_ input: PutRepositoryTriggersInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PutRepositoryTriggersOutput {
        try await self.client.execute(
            operation: "PutRepositoryTriggers", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Replaces all triggers for a repository. Used to create or delete triggers.
    ///
    /// Parameters:
    ///   - repositoryName: The name of the repository where you want to create or update the trigger.
    ///   - triggers: The JSON block of configuration information for each trigger.
    ///   - logger: Logger use during operation
    @inlinable
    public func putRepositoryTriggers(
        repositoryName: String,
        triggers: [RepositoryTrigger],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutRepositoryTriggersOutput {
        let input = PutRepositoryTriggersInput(
            repositoryName: repositoryName, 
            triggers: triggers
        )
        return try await self.putRepositoryTriggers(input, logger: logger)
    }

    /// Adds or updates tags for a resource in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates tags for a resource in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to which you want to add or update tags.
    ///   - tags: The key-value pair to use when tagging this repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceInput(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Tests the functionality of repository triggers by sending information to the trigger target. If real data is available in the repository, the test sends data from the last commit. If no data is available, sample data is generated.
    @Sendable
    @inlinable
    public func testRepositoryTriggers(_ input: TestRepositoryTriggersInput, logger: Logger = AWSClient.loggingDisabled) async throws -> TestRepositoryTriggersOutput {
        try await self.client.execute(
            operation: "TestRepositoryTriggers", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tests the functionality of repository triggers by sending information to the trigger target. If real data is available in the repository, the test sends data from the last commit. If no data is available, sample data is generated.
    ///
    /// Parameters:
    ///   - repositoryName: The name of the repository in which to test the triggers.
    ///   - triggers: The list of triggers to test.
    ///   - logger: Logger use during operation
    @inlinable
    public func testRepositoryTriggers(
        repositoryName: String,
        triggers: [RepositoryTrigger],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TestRepositoryTriggersOutput {
        let input = TestRepositoryTriggersInput(
            repositoryName: repositoryName, 
            triggers: triggers
        )
        return try await self.testRepositoryTriggers(input, logger: logger)
    }

    /// Removes tags for a resource in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags for a resource in CodeCommit. For a list of valid resources in CodeCommit, see CodeCommit Resources and Operations in the CodeCommit User Guide.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to which you want to remove tags.
    ///   - tagKeys: The tag key for each tag that you want to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceInput(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the content of an approval rule template. You can change the number of required approvals, the membership of the approval rule, and whether an approval pool is defined.
    @Sendable
    @inlinable
    public func updateApprovalRuleTemplateContent(_ input: UpdateApprovalRuleTemplateContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApprovalRuleTemplateContentOutput {
        try await self.client.execute(
            operation: "UpdateApprovalRuleTemplateContent", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the content of an approval rule template. You can change the number of required approvals, the membership of the approval rule, and whether an approval pool is defined.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template where you want to update the content of the rule.
    ///   - existingRuleContentSha256: The SHA-256 hash signature for the content of the approval rule. You can retrieve this information by using GetPullRequest.
    ///   - newRuleContent: The content that replaces the existing content of the rule. Content statements must be complete. You cannot provide only the changes.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApprovalRuleTemplateContent(
        approvalRuleTemplateName: String,
        existingRuleContentSha256: String? = nil,
        newRuleContent: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApprovalRuleTemplateContentOutput {
        let input = UpdateApprovalRuleTemplateContentInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            existingRuleContentSha256: existingRuleContentSha256, 
            newRuleContent: newRuleContent
        )
        return try await self.updateApprovalRuleTemplateContent(input, logger: logger)
    }

    /// Updates the description for a specified approval rule template.
    @Sendable
    @inlinable
    public func updateApprovalRuleTemplateDescription(_ input: UpdateApprovalRuleTemplateDescriptionInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApprovalRuleTemplateDescriptionOutput {
        try await self.client.execute(
            operation: "UpdateApprovalRuleTemplateDescription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the description for a specified approval rule template.
    ///
    /// Parameters:
    ///   - approvalRuleTemplateDescription: The updated description of the approval rule template.
    ///   - approvalRuleTemplateName: The name of the template for which you want to update the description.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApprovalRuleTemplateDescription(
        approvalRuleTemplateDescription: String,
        approvalRuleTemplateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApprovalRuleTemplateDescriptionOutput {
        let input = UpdateApprovalRuleTemplateDescriptionInput(
            approvalRuleTemplateDescription: approvalRuleTemplateDescription, 
            approvalRuleTemplateName: approvalRuleTemplateName
        )
        return try await self.updateApprovalRuleTemplateDescription(input, logger: logger)
    }

    /// Updates the name of a specified approval rule template.
    @Sendable
    @inlinable
    public func updateApprovalRuleTemplateName(_ input: UpdateApprovalRuleTemplateNameInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApprovalRuleTemplateNameOutput {
        try await self.client.execute(
            operation: "UpdateApprovalRuleTemplateName", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the name of a specified approval rule template.
    ///
    /// Parameters:
    ///   - newApprovalRuleTemplateName: The new name you want to apply to the approval rule template.
    ///   - oldApprovalRuleTemplateName: The current name of the approval rule template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApprovalRuleTemplateName(
        newApprovalRuleTemplateName: String,
        oldApprovalRuleTemplateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApprovalRuleTemplateNameOutput {
        let input = UpdateApprovalRuleTemplateNameInput(
            newApprovalRuleTemplateName: newApprovalRuleTemplateName, 
            oldApprovalRuleTemplateName: oldApprovalRuleTemplateName
        )
        return try await self.updateApprovalRuleTemplateName(input, logger: logger)
    }

    /// Replaces the contents of a comment.
    @Sendable
    @inlinable
    public func updateComment(_ input: UpdateCommentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCommentOutput {
        try await self.client.execute(
            operation: "UpdateComment", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Replaces the contents of a comment.
    ///
    /// Parameters:
    ///   - commentId: The system-generated ID of the comment you want to update. To get this ID, use GetCommentsForComparedCommit  or GetCommentsForPullRequest.
    ///   - content: The updated content to replace the existing content of the comment.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateComment(
        commentId: String,
        content: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCommentOutput {
        let input = UpdateCommentInput(
            commentId: commentId, 
            content: content
        )
        return try await self.updateComment(input, logger: logger)
    }

    /// Sets or changes the default branch name for the specified repository.  If you use this operation to change the default branch name to the current default branch name, a success message is returned even though the default branch did not change.
    @Sendable
    @inlinable
    public func updateDefaultBranch(_ input: UpdateDefaultBranchInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateDefaultBranch", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets or changes the default branch name for the specified repository.  If you use this operation to change the default branch name to the current default branch name, a success message is returned even though the default branch did not change.
    ///
    /// Parameters:
    ///   - defaultBranchName: The name of the branch to set as the default branch.
    ///   - repositoryName: The name of the repository for which you want to set or change the default branch.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDefaultBranch(
        defaultBranchName: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateDefaultBranchInput(
            defaultBranchName: defaultBranchName, 
            repositoryName: repositoryName
        )
        return try await self.updateDefaultBranch(input, logger: logger)
    }

    /// Updates the structure of an approval rule created specifically for a pull request. For example, you can change the number of required approvers and  the approval pool for approvers.
    @Sendable
    @inlinable
    public func updatePullRequestApprovalRuleContent(_ input: UpdatePullRequestApprovalRuleContentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePullRequestApprovalRuleContentOutput {
        try await self.client.execute(
            operation: "UpdatePullRequestApprovalRuleContent", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the structure of an approval rule created specifically for a pull request. For example, you can change the number of required approvers and  the approval pool for approvers.
    ///
    /// Parameters:
    ///   - approvalRuleName: The name of the approval rule you want to update.
    ///   - existingRuleContentSha256: The SHA-256 hash signature for the content of the approval rule. You can retrieve this information by using GetPullRequest.
    ///   - newRuleContent: The updated content for the approval rule.  When you update the content of the approval rule, you can specify approvers in an approval pool in one of two ways:    CodeCommitApprovers: This option only requires an Amazon Web Services account and a resource. It can be used for both IAM users and federated access users whose name matches the provided resource name. This is a very powerful option that offers a great deal of flexibility. For example, if you specify the Amazon Web Services account 123456789012 and Mary_Major, all of the following are counted as approvals coming from that user:   An IAM user in the account (arn:aws:iam::123456789012:user/Mary_Major)   A federated user identified in IAM as Mary_Major (arn:aws:sts::123456789012:federated-user/Mary_Major)   This option does not recognize an active session of someone assuming the role of CodeCommitReview with a role session name of Mary_Major (arn:aws:sts::123456789012:assumed-role/CodeCommitReview/Mary_Major) unless you include a wildcard (*Mary_Major).    Fully qualified ARN: This option allows you to specify the fully qualified Amazon Resource Name (ARN) of the IAM user or role.    For more information about IAM ARNs, wildcards, and formats, see IAM Identifiers in the IAM User Guide.
    ///   - pullRequestId: The system-generated ID of the pull request.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePullRequestApprovalRuleContent(
        approvalRuleName: String,
        existingRuleContentSha256: String? = nil,
        newRuleContent: String,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePullRequestApprovalRuleContentOutput {
        let input = UpdatePullRequestApprovalRuleContentInput(
            approvalRuleName: approvalRuleName, 
            existingRuleContentSha256: existingRuleContentSha256, 
            newRuleContent: newRuleContent, 
            pullRequestId: pullRequestId
        )
        return try await self.updatePullRequestApprovalRuleContent(input, logger: logger)
    }

    /// Updates the state of a user's approval on a pull request. The user is derived from the signed-in account when the request is made.
    @Sendable
    @inlinable
    public func updatePullRequestApprovalState(_ input: UpdatePullRequestApprovalStateInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdatePullRequestApprovalState", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the state of a user's approval on a pull request. The user is derived from the signed-in account when the request is made.
    ///
    /// Parameters:
    ///   - approvalState: The approval state to associate with the user on the pull request.
    ///   - pullRequestId: The system-generated ID of the pull request.
    ///   - revisionId: The system-generated ID of the revision.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePullRequestApprovalState(
        approvalState: ApprovalState,
        pullRequestId: String,
        revisionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdatePullRequestApprovalStateInput(
            approvalState: approvalState, 
            pullRequestId: pullRequestId, 
            revisionId: revisionId
        )
        return try await self.updatePullRequestApprovalState(input, logger: logger)
    }

    /// Replaces the contents of the description of a pull request.
    @Sendable
    @inlinable
    public func updatePullRequestDescription(_ input: UpdatePullRequestDescriptionInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePullRequestDescriptionOutput {
        try await self.client.execute(
            operation: "UpdatePullRequestDescription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Replaces the contents of the description of a pull request.
    ///
    /// Parameters:
    ///   - description: The updated content of the description for the pull request. This content replaces the existing description.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePullRequestDescription(
        description: String,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePullRequestDescriptionOutput {
        let input = UpdatePullRequestDescriptionInput(
            description: description, 
            pullRequestId: pullRequestId
        )
        return try await self.updatePullRequestDescription(input, logger: logger)
    }

    /// Updates the status of a pull request.
    @Sendable
    @inlinable
    public func updatePullRequestStatus(_ input: UpdatePullRequestStatusInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePullRequestStatusOutput {
        try await self.client.execute(
            operation: "UpdatePullRequestStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the status of a pull request.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - pullRequestStatus: The status of the pull request. The only valid operations are to update the status from OPEN to OPEN, OPEN to CLOSED or from CLOSED to CLOSED.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePullRequestStatus(
        pullRequestId: String,
        pullRequestStatus: PullRequestStatusEnum,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePullRequestStatusOutput {
        let input = UpdatePullRequestStatusInput(
            pullRequestId: pullRequestId, 
            pullRequestStatus: pullRequestStatus
        )
        return try await self.updatePullRequestStatus(input, logger: logger)
    }

    /// Replaces the title of a pull request.
    @Sendable
    @inlinable
    public func updatePullRequestTitle(_ input: UpdatePullRequestTitleInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePullRequestTitleOutput {
        try await self.client.execute(
            operation: "UpdatePullRequestTitle", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Replaces the title of a pull request.
    ///
    /// Parameters:
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - title: The updated title of the pull request. This replaces the existing title.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePullRequestTitle(
        pullRequestId: String,
        title: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePullRequestTitleOutput {
        let input = UpdatePullRequestTitleInput(
            pullRequestId: pullRequestId, 
            title: title
        )
        return try await self.updatePullRequestTitle(input, logger: logger)
    }

    /// Sets or changes the comment or description for a repository.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    @Sendable
    @inlinable
    public func updateRepositoryDescription(_ input: UpdateRepositoryDescriptionInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRepositoryDescription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets or changes the comment or description for a repository.  The description field for a repository accepts all HTML characters and all valid Unicode characters. Applications that do not HTML-encode the description and display it in a webpage can expose users to potentially malicious code. Make sure that you HTML-encode the description field in any application that uses this API to display the repository description on a webpage.
    ///
    /// Parameters:
    ///   - repositoryDescription: The new comment or description for the specified repository. Repository descriptions are limited to 1,000 characters.
    ///   - repositoryName: The name of the repository to set or change the comment or description for.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRepositoryDescription(
        repositoryDescription: String? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRepositoryDescriptionInput(
            repositoryDescription: repositoryDescription, 
            repositoryName: repositoryName
        )
        return try await self.updateRepositoryDescription(input, logger: logger)
    }

    /// Updates the Key Management Service encryption key used to encrypt and decrypt a CodeCommit repository.
    @Sendable
    @inlinable
    public func updateRepositoryEncryptionKey(_ input: UpdateRepositoryEncryptionKeyInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRepositoryEncryptionKeyOutput {
        try await self.client.execute(
            operation: "UpdateRepositoryEncryptionKey", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Key Management Service encryption key used to encrypt and decrypt a CodeCommit repository.
    ///
    /// Parameters:
    ///   - kmsKeyId: The ID of the encryption key. You can view the ID of an encryption key in the KMS console, or use the KMS APIs to programmatically retrieve a key ID. For more information about acceptable values for keyID, see  KeyId in the Decrypt API description in  the Key Management Service API Reference.
    ///   - repositoryName: The name of the repository for which you want to update the KMS encryption key used to encrypt and decrypt the repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRepositoryEncryptionKey(
        kmsKeyId: String,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRepositoryEncryptionKeyOutput {
        let input = UpdateRepositoryEncryptionKeyInput(
            kmsKeyId: kmsKeyId, 
            repositoryName: repositoryName
        )
        return try await self.updateRepositoryEncryptionKey(input, logger: logger)
    }

    /// Renames a repository. The repository name must be unique across the calling Amazon Web Services account.  Repository names are limited to 100 alphanumeric, dash, and underscore characters, and cannot include certain characters. The suffix .git is prohibited. For more information about the limits on repository names, see Quotas in the CodeCommit User Guide.
    @Sendable
    @inlinable
    public func updateRepositoryName(_ input: UpdateRepositoryNameInput, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRepositoryName", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Renames a repository. The repository name must be unique across the calling Amazon Web Services account.  Repository names are limited to 100 alphanumeric, dash, and underscore characters, and cannot include certain characters. The suffix .git is prohibited. For more information about the limits on repository names, see Quotas in the CodeCommit User Guide.
    ///
    /// Parameters:
    ///   - newName: The new name for the repository.
    ///   - oldName: The current name of the repository.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRepositoryName(
        newName: String,
        oldName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRepositoryNameInput(
            newName: newName, 
            oldName: oldName
        )
        return try await self.updateRepositoryName(input, logger: logger)
    }
}

extension CodeCommit {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: CodeCommit, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension CodeCommit {
    /// Return PaginatorSequence for operation ``describeMergeConflicts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMergeConflictsPaginator(
        _ input: DescribeMergeConflictsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMergeConflictsInput, DescribeMergeConflictsOutput> {
        return .init(
            input: input,
            command: self.describeMergeConflicts,
            inputKey: \DescribeMergeConflictsInput.nextToken,
            outputKey: \DescribeMergeConflictsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMergeConflicts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - filePath: The path of the target files used to describe the conflicts.
    ///   - maxMergeHunks: The maximum number of merge hunks to include in the output.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - repositoryName: The name of the repository where you want to get information about a merge conflict.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMergeConflictsPaginator(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        filePath: String,
        maxMergeHunks: Int? = nil,
        mergeOption: MergeOptionTypeEnum,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMergeConflictsInput, DescribeMergeConflictsOutput> {
        let input = DescribeMergeConflictsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            filePath: filePath, 
            maxMergeHunks: maxMergeHunks, 
            mergeOption: mergeOption, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return self.describeMergeConflictsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describePullRequestEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describePullRequestEventsPaginator(
        _ input: DescribePullRequestEventsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribePullRequestEventsInput, DescribePullRequestEventsOutput> {
        return .init(
            input: input,
            command: self.describePullRequestEvents,
            inputKey: \DescribePullRequestEventsInput.nextToken,
            outputKey: \DescribePullRequestEventsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describePullRequestEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - actorArn: The Amazon Resource Name (ARN) of the user whose actions resulted in the event. Examples include updating the pull request with more commits or changing the status of a pull request.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.  The default is 100 events, which is also the maximum number of events that can be returned in a result.
    ///   - pullRequestEventType: Optional. The pull request event type about which you want to return information.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - logger: Logger used for logging
    @inlinable
    public func describePullRequestEventsPaginator(
        actorArn: String? = nil,
        maxResults: Int? = nil,
        pullRequestEventType: PullRequestEventType? = nil,
        pullRequestId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribePullRequestEventsInput, DescribePullRequestEventsOutput> {
        let input = DescribePullRequestEventsInput(
            actorArn: actorArn, 
            maxResults: maxResults, 
            pullRequestEventType: pullRequestEventType, 
            pullRequestId: pullRequestId
        )
        return self.describePullRequestEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCommentReactions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentReactionsPaginator(
        _ input: GetCommentReactionsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCommentReactionsInput, GetCommentReactionsOutput> {
        return .init(
            input: input,
            command: self.getCommentReactions,
            inputKey: \GetCommentReactionsInput.nextToken,
            outputKey: \GetCommentReactionsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCommentReactions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - commentId: The ID of the comment for which you want to get reactions information.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.  The default is the same as the allowed maximum, 1,000.
    ///   - reactionUserArn: Optional. The Amazon Resource Name (ARN) of the user or identity for which you want to get reaction information.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentReactionsPaginator(
        commentId: String,
        maxResults: Int? = nil,
        reactionUserArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCommentReactionsInput, GetCommentReactionsOutput> {
        let input = GetCommentReactionsInput(
            commentId: commentId, 
            maxResults: maxResults, 
            reactionUserArn: reactionUserArn
        )
        return self.getCommentReactionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCommentsForComparedCommit(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentsForComparedCommitPaginator(
        _ input: GetCommentsForComparedCommitInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCommentsForComparedCommitInput, GetCommentsForComparedCommitOutput> {
        return .init(
            input: input,
            command: self.getCommentsForComparedCommit,
            inputKey: \GetCommentsForComparedCommitInput.nextToken,
            outputKey: \GetCommentsForComparedCommitOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCommentsForComparedCommit(_:logger:)``.
    ///
    /// - Parameters:
    ///   - afterCommitId: To establish the directionality of the comparison, the full commit ID of the after commit.
    ///   - beforeCommitId: To establish the directionality of the comparison, the full commit ID of the before commit.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results. The default is 100 comments, but you can configure up to 500.
    ///   - repositoryName: The name of the repository where you want to compare commits.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentsForComparedCommitPaginator(
        afterCommitId: String,
        beforeCommitId: String? = nil,
        maxResults: Int? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCommentsForComparedCommitInput, GetCommentsForComparedCommitOutput> {
        let input = GetCommentsForComparedCommitInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            maxResults: maxResults, 
            repositoryName: repositoryName
        )
        return self.getCommentsForComparedCommitPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCommentsForPullRequest(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentsForPullRequestPaginator(
        _ input: GetCommentsForPullRequestInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCommentsForPullRequestInput, GetCommentsForPullRequestOutput> {
        return .init(
            input: input,
            command: self.getCommentsForPullRequest,
            inputKey: \GetCommentsForPullRequestInput.nextToken,
            outputKey: \GetCommentsForPullRequestOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCommentsForPullRequest(_:logger:)``.
    ///
    /// - Parameters:
    ///   - afterCommitId: The full commit ID of the commit in the source branch that was the tip of the branch at the time the comment was made. Requirement is conditional:  afterCommitId must be specified when repositoryName is included.
    ///   - beforeCommitId: The full commit ID of the commit in the destination branch that was the tip of the branch at the time the pull request was created. Requirement is conditional:  beforeCommitId must be specified when repositoryName is included.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results. The default is 100 comments. You can return up to 500 comments with a single request.
    ///   - pullRequestId: The system-generated ID of the pull request. To get this ID, use ListPullRequests.
    ///   - repositoryName: The name of the repository that contains the pull request. Requirement is conditional: repositoryName must be specified when  beforeCommitId and afterCommitId are included.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCommentsForPullRequestPaginator(
        afterCommitId: String? = nil,
        beforeCommitId: String? = nil,
        maxResults: Int? = nil,
        pullRequestId: String,
        repositoryName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCommentsForPullRequestInput, GetCommentsForPullRequestOutput> {
        let input = GetCommentsForPullRequestInput(
            afterCommitId: afterCommitId, 
            beforeCommitId: beforeCommitId, 
            maxResults: maxResults, 
            pullRequestId: pullRequestId, 
            repositoryName: repositoryName
        )
        return self.getCommentsForPullRequestPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getDifferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getDifferencesPaginator(
        _ input: GetDifferencesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetDifferencesInput, GetDifferencesOutput> {
        return .init(
            input: input,
            command: self.getDifferences,
            inputKey: \GetDifferencesInput.nextToken,
            outputKey: \GetDifferencesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getDifferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - afterCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit.
    ///   - afterPath: The file path in which to check differences. Limits the results to this path. Can also be used to specify the changed name of a directory or folder, if it has changed. If not specified, differences are shown for all paths.
    ///   - beforeCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, the full commit ID). Optional. If not specified, all changes before the afterCommitSpecifier value are shown. If you do not use beforeCommitSpecifier in your request, consider limiting the results with maxResults.
    ///   - beforePath: The file path in which to check for differences. Limits the results to this path. Can also be used to specify the previous name of a directory or folder. If beforePath and afterPath are not specified, differences are shown for all paths.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - repositoryName: The name of the repository where you want to get differences.
    ///   - logger: Logger used for logging
    @inlinable
    public func getDifferencesPaginator(
        afterCommitSpecifier: String,
        afterPath: String? = nil,
        beforeCommitSpecifier: String? = nil,
        beforePath: String? = nil,
        maxResults: Int? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetDifferencesInput, GetDifferencesOutput> {
        let input = GetDifferencesInput(
            afterCommitSpecifier: afterCommitSpecifier, 
            afterPath: afterPath, 
            beforeCommitSpecifier: beforeCommitSpecifier, 
            beforePath: beforePath, 
            maxResults: maxResults, 
            repositoryName: repositoryName
        )
        return self.getDifferencesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getMergeConflicts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getMergeConflictsPaginator(
        _ input: GetMergeConflictsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetMergeConflictsInput, GetMergeConflictsOutput> {
        return .init(
            input: input,
            command: self.getMergeConflicts,
            inputKey: \GetMergeConflictsInput.nextToken,
            outputKey: \GetMergeConflictsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getMergeConflicts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - conflictDetailLevel: The level of conflict detail to use. If unspecified, the default FILE_LEVEL is used, which returns a not-mergeable result if the same file has differences in both branches. If LINE_LEVEL is specified, a conflict is considered not mergeable if the same file in both branches has differences on the same line.
    ///   - conflictResolutionStrategy: Specifies which branch to use when resolving conflicts, or whether to attempt automatically merging two versions of a file. The default is NONE, which requires any conflicts to be resolved manually before the merge operation is successful.
    ///   - destinationCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - maxConflictFiles: The maximum number of files to include in the output.
    ///   - mergeOption: The merge option or strategy you want to use to merge the code.
    ///   - repositoryName: The name of the repository where the pull request was created.
    ///   - sourceCommitSpecifier: The branch, tag, HEAD, or other fully qualified reference used to identify a commit (for example, a branch name or a full commit ID).
    ///   - logger: Logger used for logging
    @inlinable
    public func getMergeConflictsPaginator(
        conflictDetailLevel: ConflictDetailLevelTypeEnum? = nil,
        conflictResolutionStrategy: ConflictResolutionStrategyTypeEnum? = nil,
        destinationCommitSpecifier: String,
        maxConflictFiles: Int? = nil,
        mergeOption: MergeOptionTypeEnum,
        repositoryName: String,
        sourceCommitSpecifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetMergeConflictsInput, GetMergeConflictsOutput> {
        let input = GetMergeConflictsInput(
            conflictDetailLevel: conflictDetailLevel, 
            conflictResolutionStrategy: conflictResolutionStrategy, 
            destinationCommitSpecifier: destinationCommitSpecifier, 
            maxConflictFiles: maxConflictFiles, 
            mergeOption: mergeOption, 
            repositoryName: repositoryName, 
            sourceCommitSpecifier: sourceCommitSpecifier
        )
        return self.getMergeConflictsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listApprovalRuleTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listApprovalRuleTemplatesPaginator(
        _ input: ListApprovalRuleTemplatesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListApprovalRuleTemplatesInput, ListApprovalRuleTemplatesOutput> {
        return .init(
            input: input,
            command: self.listApprovalRuleTemplates,
            inputKey: \ListApprovalRuleTemplatesInput.nextToken,
            outputKey: \ListApprovalRuleTemplatesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listApprovalRuleTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listApprovalRuleTemplatesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListApprovalRuleTemplatesInput, ListApprovalRuleTemplatesOutput> {
        let input = ListApprovalRuleTemplatesInput(
            maxResults: maxResults
        )
        return self.listApprovalRuleTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssociatedApprovalRuleTemplatesForRepository(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssociatedApprovalRuleTemplatesForRepositoryPaginator(
        _ input: ListAssociatedApprovalRuleTemplatesForRepositoryInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssociatedApprovalRuleTemplatesForRepositoryInput, ListAssociatedApprovalRuleTemplatesForRepositoryOutput> {
        return .init(
            input: input,
            command: self.listAssociatedApprovalRuleTemplatesForRepository,
            inputKey: \ListAssociatedApprovalRuleTemplatesForRepositoryInput.nextToken,
            outputKey: \ListAssociatedApprovalRuleTemplatesForRepositoryOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssociatedApprovalRuleTemplatesForRepository(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - repositoryName: The name of the repository for which you want to list all associated approval rule templates.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssociatedApprovalRuleTemplatesForRepositoryPaginator(
        maxResults: Int? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssociatedApprovalRuleTemplatesForRepositoryInput, ListAssociatedApprovalRuleTemplatesForRepositoryOutput> {
        let input = ListAssociatedApprovalRuleTemplatesForRepositoryInput(
            maxResults: maxResults, 
            repositoryName: repositoryName
        )
        return self.listAssociatedApprovalRuleTemplatesForRepositoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBranches(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBranchesPaginator(
        _ input: ListBranchesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBranchesInput, ListBranchesOutput> {
        return .init(
            input: input,
            command: self.listBranches,
            inputKey: \ListBranchesInput.nextToken,
            outputKey: \ListBranchesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBranches(_:logger:)``.
    ///
    /// - Parameters:
    ///   - repositoryName: The name of the repository that contains the branches.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBranchesPaginator(
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBranchesInput, ListBranchesOutput> {
        let input = ListBranchesInput(
            repositoryName: repositoryName
        )
        return self.listBranchesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFileCommitHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFileCommitHistoryPaginator(
        _ input: ListFileCommitHistoryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFileCommitHistoryRequest, ListFileCommitHistoryResponse> {
        return .init(
            input: input,
            command: self.listFileCommitHistory,
            inputKey: \ListFileCommitHistoryRequest.nextToken,
            outputKey: \ListFileCommitHistoryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFileCommitHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - commitSpecifier: The fully quaified reference that identifies the commit that contains the file. For example, you can specify a full commit ID, a tag, a branch name, or a reference such as refs/heads/main. If none is provided, the head commit is used.
    ///   - filePath: The full path of the file whose history you want to retrieve, including the name of the file.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - repositoryName: The name of the repository that contains the file.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFileCommitHistoryPaginator(
        commitSpecifier: String? = nil,
        filePath: String,
        maxResults: Int? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFileCommitHistoryRequest, ListFileCommitHistoryResponse> {
        let input = ListFileCommitHistoryRequest(
            commitSpecifier: commitSpecifier, 
            filePath: filePath, 
            maxResults: maxResults, 
            repositoryName: repositoryName
        )
        return self.listFileCommitHistoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPullRequests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPullRequestsPaginator(
        _ input: ListPullRequestsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPullRequestsInput, ListPullRequestsOutput> {
        return .init(
            input: input,
            command: self.listPullRequests,
            inputKey: \ListPullRequestsInput.nextToken,
            outputKey: \ListPullRequestsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPullRequests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - authorArn: Optional. The Amazon Resource Name (ARN) of the user who created the pull request. If used, this filters the results  to pull requests created by that user.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - pullRequestStatus: Optional. The status of the pull request. If used, this refines the results to the pull requests that match the specified status.
    ///   - repositoryName: The name of the repository for which you want to list pull requests.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPullRequestsPaginator(
        authorArn: String? = nil,
        maxResults: Int? = nil,
        pullRequestStatus: PullRequestStatusEnum? = nil,
        repositoryName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPullRequestsInput, ListPullRequestsOutput> {
        let input = ListPullRequestsInput(
            authorArn: authorArn, 
            maxResults: maxResults, 
            pullRequestStatus: pullRequestStatus, 
            repositoryName: repositoryName
        )
        return self.listPullRequestsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRepositories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRepositoriesPaginator(
        _ input: ListRepositoriesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRepositoriesInput, ListRepositoriesOutput> {
        return .init(
            input: input,
            command: self.listRepositories,
            inputKey: \ListRepositoriesInput.nextToken,
            outputKey: \ListRepositoriesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRepositories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - order: The order in which to sort the results of a list repositories operation.
    ///   - sortBy: The criteria used to sort the results of a list repositories operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRepositoriesPaginator(
        order: OrderEnum? = nil,
        sortBy: SortByEnum? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRepositoriesInput, ListRepositoriesOutput> {
        let input = ListRepositoriesInput(
            order: order, 
            sortBy: sortBy
        )
        return self.listRepositoriesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRepositoriesForApprovalRuleTemplate(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRepositoriesForApprovalRuleTemplatePaginator(
        _ input: ListRepositoriesForApprovalRuleTemplateInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRepositoriesForApprovalRuleTemplateInput, ListRepositoriesForApprovalRuleTemplateOutput> {
        return .init(
            input: input,
            command: self.listRepositoriesForApprovalRuleTemplate,
            inputKey: \ListRepositoriesForApprovalRuleTemplateInput.nextToken,
            outputKey: \ListRepositoriesForApprovalRuleTemplateOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRepositoriesForApprovalRuleTemplate(_:logger:)``.
    ///
    /// - Parameters:
    ///   - approvalRuleTemplateName: The name of the approval rule template for which you want to list repositories that are associated with that template.
    ///   - maxResults: A non-zero, non-negative integer used to limit the number of returned results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRepositoriesForApprovalRuleTemplatePaginator(
        approvalRuleTemplateName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRepositoriesForApprovalRuleTemplateInput, ListRepositoriesForApprovalRuleTemplateOutput> {
        let input = ListRepositoriesForApprovalRuleTemplateInput(
            approvalRuleTemplateName: approvalRuleTemplateName, 
            maxResults: maxResults
        )
        return self.listRepositoriesForApprovalRuleTemplatePaginator(input, logger: logger)
    }
}

extension CodeCommit.DescribeMergeConflictsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.DescribeMergeConflictsInput {
        return .init(
            conflictDetailLevel: self.conflictDetailLevel,
            conflictResolutionStrategy: self.conflictResolutionStrategy,
            destinationCommitSpecifier: self.destinationCommitSpecifier,
            filePath: self.filePath,
            maxMergeHunks: self.maxMergeHunks,
            mergeOption: self.mergeOption,
            nextToken: token,
            repositoryName: self.repositoryName,
            sourceCommitSpecifier: self.sourceCommitSpecifier
        )
    }
}

extension CodeCommit.DescribePullRequestEventsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.DescribePullRequestEventsInput {
        return .init(
            actorArn: self.actorArn,
            maxResults: self.maxResults,
            nextToken: token,
            pullRequestEventType: self.pullRequestEventType,
            pullRequestId: self.pullRequestId
        )
    }
}

extension CodeCommit.GetCommentReactionsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.GetCommentReactionsInput {
        return .init(
            commentId: self.commentId,
            maxResults: self.maxResults,
            nextToken: token,
            reactionUserArn: self.reactionUserArn
        )
    }
}

extension CodeCommit.GetCommentsForComparedCommitInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.GetCommentsForComparedCommitInput {
        return .init(
            afterCommitId: self.afterCommitId,
            beforeCommitId: self.beforeCommitId,
            maxResults: self.maxResults,
            nextToken: token,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.GetCommentsForPullRequestInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.GetCommentsForPullRequestInput {
        return .init(
            afterCommitId: self.afterCommitId,
            beforeCommitId: self.beforeCommitId,
            maxResults: self.maxResults,
            nextToken: token,
            pullRequestId: self.pullRequestId,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.GetDifferencesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.GetDifferencesInput {
        return .init(
            afterCommitSpecifier: self.afterCommitSpecifier,
            afterPath: self.afterPath,
            beforeCommitSpecifier: self.beforeCommitSpecifier,
            beforePath: self.beforePath,
            maxResults: self.maxResults,
            nextToken: token,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.GetMergeConflictsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.GetMergeConflictsInput {
        return .init(
            conflictDetailLevel: self.conflictDetailLevel,
            conflictResolutionStrategy: self.conflictResolutionStrategy,
            destinationCommitSpecifier: self.destinationCommitSpecifier,
            maxConflictFiles: self.maxConflictFiles,
            mergeOption: self.mergeOption,
            nextToken: token,
            repositoryName: self.repositoryName,
            sourceCommitSpecifier: self.sourceCommitSpecifier
        )
    }
}

extension CodeCommit.ListApprovalRuleTemplatesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListApprovalRuleTemplatesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension CodeCommit.ListAssociatedApprovalRuleTemplatesForRepositoryInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListAssociatedApprovalRuleTemplatesForRepositoryInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.ListBranchesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListBranchesInput {
        return .init(
            nextToken: token,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.ListFileCommitHistoryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListFileCommitHistoryRequest {
        return .init(
            commitSpecifier: self.commitSpecifier,
            filePath: self.filePath,
            maxResults: self.maxResults,
            nextToken: token,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.ListPullRequestsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListPullRequestsInput {
        return .init(
            authorArn: self.authorArn,
            maxResults: self.maxResults,
            nextToken: token,
            pullRequestStatus: self.pullRequestStatus,
            repositoryName: self.repositoryName
        )
    }
}

extension CodeCommit.ListRepositoriesForApprovalRuleTemplateInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListRepositoriesForApprovalRuleTemplateInput {
        return .init(
            approvalRuleTemplateName: self.approvalRuleTemplateName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension CodeCommit.ListRepositoriesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> CodeCommit.ListRepositoriesInput {
        return .init(
            nextToken: token,
            order: self.order,
            sortBy: self.sortBy
        )
    }
}
